/src/main/resources/static is the suggested folder for static content in Spring boot.

You can create a JS file for sending an alert by creating a custom file named custom.js in /src/main/resources/static/js/ directory with the below code

The first step to connect the database like Oracle or MySql is adding the dependency for your database connector to pom.xml.

The next step is the elimination of H2 Dependency from pom.xml

Step 3 includes the schema and table to establish your database.

The next step is configuring the database by using Configure application. properties to connect to your database.

And the last step is to restart your device and your connection is ready to use.

JPA is a specification/Interface whereas Hibernate is one of the JPA implementations.

Various spring sub-projects are as follows:

JDBC: this module empowers a JDBC-deliberation layer that evaluates the need to do JDBC coding for particular vendor databases

Core: a key module that gives basic parts of the system, such as IoC or DI

Web: a web-situated joining module, giving multipart document upload, listeners members, and web-arranged application context functionalities

ORM integration: gives mix layers to well-known protest object-relational mapping APIs, for example, JPA, JDO, and Hibernate

AOP mod: perspective-orientedented programming execution is permitting the meaning of clean strategy interceptors and pointcuts.

MVC system: a web module executing the Model View Controller configuration design

Aspect-Oriented Programming (AOP) supplements Object-Oriented Programming (OOP) by giving another mindset about program structure. The key unit of measured quality in OOP is the class, while in AOP the unit of particularity is the viewpoint. Angles empower the modularization of concerns, for example, transaction management that cut over numerous sorts and questions.

Spring Security is a groundbreaking and very adjustable authentication and access-control structure. It is the true standard for securing Spring-based applications. Spring Security is a system that spotlights giving both authentication and approval to Java applications. Like all spring ventures, the genuine power of Spring Security is found in how effectively it can be reached out to meet custom prerequisites.

The embedded container is only one component of Spring Boot

Traditional WAR additionally benefits a considerable measure from Spring Boot

Automatic Spring MVC setup, including Dispatcher Servlet

Sensible defaults in light of the class-path content

The embedded content can be utilized during improvement.

Yes, we can control logging with spring boot.

Usage of spring security in the Spring boot application requires quite a little configuration. You have to include a spring-boot-starter-security starter in pom.xml. You need to make a spring config class, which will expand WebSecurity Configure Adapter and override the expected strategy to accomplish security in the spring boot application.

Configuration file name which is utilized as a part of Spring boot ventures is known as application. Properties. It is vital to document as it is utilized to abrogate all default configurations.

No, it isn’t conceivable starting at now. Spring boot is restricted to Spring applications only.

The configuration file name, which is utilized as a part of spring boot projects is application. properties. This document is very important where we would overwrite all the default setups. Ordinarily, we need to hold this document under the assets folder of the project.

Spring Boot gives different properties, which can be indicated in our project’s application. Properties record. These properties have default values, and you can set that inside the properties record. Properties are utilized to set qualities like a server-port number, database association configuration, and much more.

It takes after the "Opinionated Defaults Configuration" Approach to lessen Developer exertion. Because of the Opinionated perspective of spring boot, what is required to begin yet additionally we can get out if not appropriate for the application. Spring Boot utilizes sensible defaults, “opinions,” for the most part in light of the classpath substance.

The configuration record utilized as a part of spring boot ventures is an application. Properties. This record is imperative where we would overwrite all the default designs. Regularly we need to hold this document under the assets envelope of the project.

Spring Boot Actuator is a sub-task of Spring Boot. It adds a few creation review administrations to your application with little exertion on your part. There are also has numerous features added to your application out-of-the-case for dealing with the administration in a production (or other) condition. They’re used to uncover diverse kinds of data about the running application – health, measurements, information, dump, env, and so on.

Spring boot accompanies Dev Tools, which is acquainted with increasing the profitability of designers. You don’t have to redeploy your application each time you influence the changes. The developer can reload the progressions without restart of the server. It maintains a strategic distance from the agony of redeploying applications each time when you roll out any improvement. This module will be utilized in a production environment.

The Spring Initializer is a web application that can produce a Spring Boot project structure for you. It doesn’t create any application code. However, it will give you an essential project structure and either a Maven or a Gradle build specification to fabricate your code with. You should simply compose the application code.

Spring Initializer can be utilized in a few different ways, including:

The reason behind having a Spring-boot-maven module is it gives a couple of charges which empower you to package the code as a container or run the application.

spring-boot: run operates your Spring Boot application.

spring-boot: repackage it repackages your jug/war to be executable.

spring-boot: start and spring-boot: stop to deal with the lifecycle of your Spring Boot application (i.e., for joining tests).

spring-boot: build-data creates build data that can be utilized by the Actuator.

Various Spring Boot Features are as follows:

Here are some of the various advantages of using Spring Boot:

It is quite easy to create Spring Based applications with Java or Groovy.

It lessens lots of improvement time and expands profitability.

It abstains from writing lots of standard Codes, Annotations, and XML Configuration.

It is quite easy to coordinate Spring Boot Application with its Spring Ecosystem like Spring JDBC, Spring ORM, Spring Data, Spring Security, and so forth.

It takes after the "Opinionated Defaults Configuration" Approach to diminish Developer effort

It gives Embedded HTTP servers like Tomcat, Jetty, and more to create and test our web applications effectively.

It gives CLI (Command Line Interface) a tool to create and test Spring Boot (Java or Groovy) Applications from commanding prompt very easily and rapidly.

It gives lots of modules to create and test Spring Boot Applications effectively utilizing Build Tools like Maven and Gradle

It provides loads of plug-ins to work with implanted and in-memory Databases effortlessly.

Spring Boot is a system from "The Spring Team" to facilitate the bootstrapping and development of new Spring Applications. It gives defaults to code, and annotation configurations to snappy begin new spring projects at no time. It takes after the "Opinionated Defaults Configuration" Approach to escape from a lot of standard code and configuration to enhance the Development, Unit Test, and Integration Test Process.

Spring Boot AutoConfigurator is used by Spring Boot Framework to provide “Auto-Configuration”.

Spring Boot Starters are just JAR Files. They are used by Spring Boot Framework to provide “Auto-Dependency Resolution”.

Spring boot makes it very easy to build microservices. If you are moving to microservices architecture Spring Boot is among the top frameworks which support tons of features to build microservices quickly. Spring boot has huge community support and Spring Cloud has plenty of modules to integrate almost all popular open-source tools. Spring Boot makes it very easy to create a standalone application by providing auto configurations. It provides production-ready features like Actuator.

It is easy to learn and requires less code to develop the applications.

It is a Spring module that offers Rapid Application Development to Spring framework. Spring module is used to create an application based on the Spring framework which requires configuring a few Spring files.

Features of Spring Boot that make it different

 Creates stand-alone spring application with minimal configuration needed.

 It has embedded tomcat, jetty which makes it just code and run the application.

 Provide production-ready features such as metrics, health checks, and externalized configuration.

The configuration file for Spring is an XML file that contains the class information for a project. They describe the configuration of each class, how they’re introduced to other classes and dependencies across the program.

Use content security policies to prevent XSS attacks

Compatible, use @ImportResourceannotations to import old Spring project configuration files.

In Spring Boot, there are several ways to load a configuration.

 Spring Boot supports Java Util Logging, Log4j2, and Lockback as the logging framework. If you use the Starters launcher, Spring Boot will use Logback as the default logging framework.

A) Spring Boot can bind variables via @PropertySource, @Value, @Environment, @ConfigurationProperties.

 You can implement the interface ApplicationRunner or CommandLineRunner. These two interfaces are implemented in the same way. They only provide a run method.

Starters can be understood as a launcher, which contains a set of dependencies that can be integrated into the application. You can integrate Spring and other technologies in one place without having to find sample code and dependencies everywhere. If you want to use Spring JPA to access the database, just add the spring-boot-starter-data-JPA launcher dependency to use.

Starters contain dependencies that are needed in many projects. They run quickly and continuously and are a set of supported management transitive dependencies.

This directory structure is the mainstream and recommended practice, and the @SpringBootApplication annotation is added to the main entry class to enable Spring Boot’s capabilities, such as automatic configuration, component scanning, and so on.

Note @EnableAutoConfiguration, @Configuration, @ConditionalOnClass is the core of automatic configuration, first, it must be a configuration file, and then according to the classpath to have this class to automatically configure.

Spring provides a very useful way to handle exceptions using ControllerAdvice. We handle all exceptions thrown by the controller class by implementing a ControlerAdvice class.

FreeMarker is a Java-based templating engine that initially focused on dynamic web page generation using the MVC software architecture. The main advantage of using Freemarker is the complete separation of the presentation and business layers.

Programmers can handle application code, and designers can handle HTML page design. Finally, you can combine these with freemarker to give the final output page.

Spring Boot Batch provides reusable functions that are important when working with large numbers of records, including logging/tracing, transaction management, job processing statistics, job restarts, skipping, and resource management.

It also provides more advanced technical services and features that enable extremely high volume and high-performance batch operations through optimization and partitioning techniques. Simple and complex high-volume batch jobs can use the framework to process a large amount of information in a highly scalable manner.

Spring Profiles allows users to register beans based on configuration files (dev, test, prod, etc.). Therefore, when the application is running in development, only certain beans can be loaded, while in PRODUCTION, some other beans can be loaded.

Suppose we require that the Swagger document is only for the QA environment and all other documents are disabled. This can be done using a configuration file. Spring Boot makes it easy to use configuration files.

 Swagger is widely used for visual APIs, using the Swagger UI to provide an online sandbox for front-end developers. A swagger is a tool for generating visual representations of RESTful web services, specifications, and full framework implementations.

It enables documents to be updated at the same speed as the server. When properly defined by Swagger, consumers can use a minimal amount of implementation logic to understand and interact with remote services. Therefore, Swagger eliminates the guesswork when calling the service.

 Packing with commands or putting them into a container

 It is not necessary, and a container such as Tomcat/ Jetty is built in.

Inherit the spring-boot-starter-parent project

Import spring-boot-dependencies project dependencies

The annotation above the startup class is @SpringBootApplication, which is also a core annotation for Spring Boot. The main combination contains the following three annotations:

@SpringBootConfiguration: Combines the @Configuration annotation to implement the configuration file.

@EnableAutoConfiguration: Turns on automatic configuration. You can also turn off an automatic configuration option, such as turning off data source auto-configuration: @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class }).

A) The core configuration files for Spring Boot are the application and bootstrap configuration files.

The application configuration file is easy to understand and is primarily used for the automated configuration of Spring Boot projects.

The bootstrap configuration file has the following application scenarios.

When using Spring Cloud Config to configure the hub, you need to add the configuration properties of the connection to the configuration center in the bootstrap configuration file to load the configuration information of the external configuration center.

Some fixed attributes that cannot be overridden;

Java Spring Boot is mainly used to support the backend or server-side of Microservices applications built using the Spring framework.

For Spring Boot to function correctly, the following system requirements are necessary: Java version - Java8+, Java Spring 5.1.9, Maven 3.3+ (Explicit support), Gradle 4.4+ (Explicit Support), Jetty 9.4 (Container Support), Undertow 2.0 (Servlet Version 4.0).

If you’re a fresher, you’re not necessarily expected to know the functioning of various Java Microservices tools and frameworks. Thus, Spring Boot interview questions are mostly asked at interviews for experienced developers.

The Spring Boot tool is used mainly to configure Rest APIs and enhance the performance of applications created using Spring. 

Knowing your way around Java Spring Boot is important because FAANG+ companies often test your knowledge of popular Java frameworks and Microservices in coding and design rounds of technical interviews.

You can enable HTTP/2 support in Spring using the function: server.http2.enabled=true

Spring Initializr is a tool used to create projects in Spring Boot by specifying the project details. The following steps need to be followed to create a project using Spring Initializr:

Choose the project and its dependencies, such as artifacts and Groups.

Generate the project and extract it into the system.

Ensure the source project has the pom.xml file while importing the project and running it.

To integrate Theymeleaf in Spring Boot, the following code needs to be used:

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-devtools</artifactId>

This is a common Java Spring Boot interview question asked for experienced programmers in technical interviews. Theymeleaf is a server-side template engine used to embed natural templates to web applications. Theymeleaf can be integrated into applications built using Spring and HTML5. 

The Spring Boot Actuator is a core feature in Spring Boot that enables developers to analyze application metrics while the application is running and optimize or fix issues wherever applicable. Aspects like the currently running threads, CPU usage, and beans can be evaluated to optimize the application’s performance. 

Through SPring Actuators, developers can easily access REST points and gather information from multiple web sources. 

This is a common Java Spring Boot interview question asked in technical interviews. The different starters in Spring Boot include: 

This is one of the most popular Java Spring Boot interview Questions asked in technical interviews. Spring Boot starters are a set of components that provide dependencies during the development phase. Starters help initiate the application building process by providing a wide variety of dependencies. Starters in Spring Boot are contained in the org. spring framework. boot group. 

This is one of the most popular Java Spring Boot interview questions asked in developer interviews. Spring Boot includes four main components that are:

Spring Boot starter parent is a convenient and easy way for dependency management. With each release, Spring Boot provides a curated list of its supports. While working on the Spring Boot application, you may not need to provide the version number for the dependencies as these are automatically taken care of by Spring Boot. Spring Boot manages this curated list of dependencies through the starter pom.

We can enable HTTP/2 support by using server.http2.enabled configuration property. Please refer to the application server documentation as HTTP/2 is not supported by all web servers.

This property file is the central control system for your Spring Boot application. Spring Boot applies its typical convention over configuration approach to property files. Spring Boot provides default applications.properties file for the default configurations. When Spring Boot application starters, it refers to this configuration file for the default values.

Spring boot specified various common default properties inside the application. properties to support Logging, AOP, Server configurations, caching, JPA, etc. We need not specify all the default properties in all the cases. We can specify them only on-demand.

No, Spring Boot does not provide an out-of-the-box solution in case our application needs multiple Data-sources (e.g. multi-tenant system). Spring Boot provides multiple extension points to enable support for multiple data sources. Read multiple data sources with Spring Boot for more detail.

Spring Boot admin is a community project used to manage and monitor your Spring Boot applications. The client application gets registered with the admin server (via HTTP) or is discovered using Spring Cloud discover server like Eureka, Consul. Each client application needs to have Spring Actuator jars in it. The endpoints provided by the Actuator jar are polled by the Spring Boot Admin server to get the metrics of that application.

Actuators' endpoints let you monitor and interact with your application. Spring Boot includes several built-in endpoints and lets you add your own. To know more details about these endpoints read Spring Boot Actuator.

Yes, Spring Boot supports creating both web and non-web applications. To create a non-web application, you need to remove web dependencies from your classpath along with changing the way Spring Boot creates the application context. Please read Standalone Application Using Spring Boot for more details.

Spring Boot automatically starts an application in web server mode if it finds the web module in the classpath. To disable the web server configuration, set the web application type to none in the application.properties file.

We can control the package type generation in our Spring Boot project using the spring-boot-maven plugin To build a war file, we need to follow these 2 steps.

Set the packaging type as a war in our pom.xml file.

Mark the embedded container dependencies as “provided” (To build a war file that is both executable and deployable into an external container.)

         <groupId>org.springframework.boot</groupId>

         <artifactId>spring-boot-starter-web</artifactId>

         <artifactId>spring-boot-starter-tomcat</artifactId>

There are two ways to set the active profile in Spring Boot.

Pass in the active profile as an argument while launching the application.

Use the application.properties file to set the active profile.

Spring Boot provides multiple ways to the active profile. We can pass profile information through the command line or use the application.properties, Spring Boot also provides a way to set profile programmatically. Use profile-specific configuration files in our Spring Boot application. we need the naming convention of application-{profile}.properties where profile defines the name of the intended profile. It will load the profile from the same location as the application.properties file.

Using Spring Boot achieving pagination is very simple. Using the Spring Data-JPA this is achieved passing pageable org. spring framework.data.domain.Pageable to the repository methods.

For integrating Spring Boot and ActiveMQ we use the spring-boot-starter-activemq dependency

It requires very little configuration and no boilerplate code.

For Implementing security for Spring Boot we use the spring-boot-starter-security dependency and have to add the Security config. It requires very little code. Config class will have to extend WebSecurityConfigurerAdapter and override its methods.

YAML is a human-readable data serialization language. It is commonly used for configuration files.

Compared to the properties file, the YAML file is much more structured and less confusing in case we want to add complex properties in the configuration file. As can be seen, YAML has hierarchical configuration data.

By default, all sensitive HTTP endpoints are secured such that only users that have an ACTUATOR role may access them. Security is enforced using the standard HttpServletRequest.isUserInRole method.

It is suggested to disable security only if the actuator endpoints are accessed behind a firewall.

To run a spring boot application on a custom port, you can specify the port in the application. properties.

We will be implementing Spring Boot +JWT + MYSQL Hello World Example

JWT stands for JSON Web Token. JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. The client will need to authenticate with the server using the credentials only once. During this time the server validates the credentials and returns the client a JSON Web Token(JWT). For all future requests, the client can authenticate itself to the server using this JSON Web Token(JWT) and so does not need to send the credentials like username and password.

The spring boot actuator is one of the important features of the spring boot framework. Spring boot actuator helps you to access the current state of the running application in a production environment. Several metrics have to be checked and monitored in the production environment. Even some external applications may be using those services to trigger the alert message to the concerned person. The actuator module exposes a set of REST endpoints that can be directly accessed as an HTTP URL to check the status.

Spring JavaConfig is a product of the Spring community that provides a pure-Java approach to configuring the Spring IoC Container. It thus helps avoid using XML configurations. The advantages of using JavaConfig are

Object-oriented configuration. Because configurations are defined as classes in JavaConfig, users can take full advantage of object-oriented features in Java. One configuration class may subclass another, overriding its @Bean methods, etc.

Reduced or eliminated XML configuration. The benefits of externalized configuration based on the principles of dependency injection have been proven. However, many developers would prefer not to switch back and forth between XML and Java. JavaConfig provides developers with a pure-Java approach to configuring the Spring container that is conceptually similar to XML configuration. It is technically possible to configure the container using only JavaConfig configuration classes, however in practice, many have found it ideal to mix-and-match JavaConfig with XML.

Type-safe and refactoring-friendly. JavaConfig provides a type-safe approach to configuring the Spring container. Thanks to Java 5.0's support for generics, it is now possible to retrieve beans by type rather than by name, free of any casting or string-based lookups.

Spring Boot is a framework built on top of the Spring framework. It eases out configuring & setting up of applications. This is not true not only for standalone applications but also for web-based applications. It reduces boilerplate code and minimizes the spring configuration a lot.

It scans the libraries on its classpath and automatically configures the required classes. This gets us started without writing much code.

Most of the time, Spring boot sets up the default configuration for libraries on its classpath. If your requirement is different from default configuration & setup, Spring boot provides an easy way of overriding the defaults. For example, let’s say you have a Spring Data library on the classpath. In this case, Spring Boot automatically sets up a connection to the Database along with the Data Source class. Let’s say if you want to change the port where the database is running, Spring Boot provides an easy way of configuring or overriding it. You can set up those in the application.properties ( or YAML /XML).

Spring Boot also provides opinionated Spring-based third-party libraries. They are known as Starters. The advantage is that a starter has all third-party dependencies included hence this minimizes the configuration in the application. Secondly, starters also provide default setup & configuration which eases out the integration of the library into the application and get started.

Below is the basic component, which plays a vital role in the spring boot framework for configuration, development, deployment, and execution of microservices-based applications.

Below are the key dependencies which you need to add in maven-based or Gradle-based Applications, to make the application compatible to use spring boot functionality. 

Spring boot provides many abstraction layers to ease the development, underneath there are vital libraries that work for us. 

Below is the key function performing internally.

Using @EnableAutoConfigure annotation the spring boot application configures the spring boot application automatically. 

E.g. If you need MySQL DB in your project, but you haven’t configured any database connection, in that case, Spring boot auto-configures as an in-memory database.

The entry point of the spring boot application is a class that contains @SpringBootApplication annotation and has the main method.

Spring boot scans all the components included in the project by using @ComponentScan annotation.

Let’s say we need the Spring and JPA for database connection, then we no need to add the individual dependency we can simply add the spring-boot-starter-data-JPA in the project.

Spring boot follows the naming convention for dependency like spring-boot-starter. 

Besides advantages, there are a few issues, where we should think about adopting the spring boot framework to develop the microservice-based architecture. 

Spring boot unnecessary increases the size of the build with unused dependencies.

Not able to create the war file manually and difficult to configure externally.

Doesn’t provide much control and tuning the running build.

It’s only suitable for micro-services that eventually need to deploy in docker, but not large or mono lithics web services. 

Spring boot doesn’t provide good compatibility if we are integrating a third-party framework. 

When developing applications for the enterprise, we typically deal with multiple environments such as Dev, QA, and Prod. The configuration properties for these environments are different.

For example, we might be using an embedded H2 database for Dev, but Prod could have the proprietary Oracle or DB2. Even if the DBMS is the same across environments, the URLs would be different.

We can change the default port of a server embedded in Spring Boot using one of these ways:

Using a properties file – We can define this in an application.properties (or application.yml) file using the property server. port.

Programmatically – In our main @SpringBootApplication class, we can set the server. the port on the SpringApplication instance.

Using the command line – When running the application as a jar file, we can set the server. port as a java command argument:

java -jar -Server.port=8081 myspringproject.jar

The primary annotations that Spring Boot offers reside in its org.springframework.boot.autoconfigure and its sub-packages.

@EnableAutoConfiguration – to make Spring Boot look for auto-configuration beans on its classpath and automatically apply them

@SpringBootApplication – to denote the main class of a Boot Application. This annotation combines @Configuration, @EnableAutoConfiguration and @ComponentScan annotations with their default attributes.

Spring Boot Annotations offers more insight into the subject.

YAML offers many advantages over properties files:

Perfect for hierarchical configuration data, which is also represented in a better, more readable format

Support for maps, lists, and scalar types

Can include several profiles in the same file (since Spring Boot 2.4.0, this is possible for properties files too)

However, writing it can be a little difficult and error-prone due to its indentation rules.

For details and work samples, please refer to our Spring YAML vs Properties tutorial.

Relaxed binding in Spring Boot applies to the type-safe binding of configuration properties.

With relaxed binding, the key of a property doesn't need to be an exact match of a property name. Such an environment property can be written in camelCase, kebab-case, snake_case, or uppercase with words separated by underscores.

For example, if a property in a bean class with the @ConfigurationProperties annotation is named myProp, it can be bound to any of these environment properties: myProp, my-prop, my_prop, or MY_PROP.

Spring Boot provides support for external configuration, allowing us to run the same application in various environments. We can use properties files, YAML files, environment variables, system properties, and command-line option arguments to specify configuration properties.

We can then gain access to those properties using the @Value annotation, a bound object via the @ConfigurationProperties annotation, or the Environment abstraction.

To register an auto-configuration class, we must have its fully qualified name listed under the EnableAutoConfiguration key in the META-INF/spring.factories file:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.baeldung.autoconfigure.CustomAutoConfiguration

If we build a project with Maven, that file should be placed in the resources/META-INF directory, which will end up in the mentioned location during the package phase.

Each starter plays a role as a one-stop-shop for all the Spring technologies we need. Other required dependencies are then transitively pulled in and managed consistently.

All starters are under the org. spring framework. boot group and their names start with spring-boot-starter-. This naming pattern makes it easy to find starters, especially when working with IDEs that support searching dependencies by name.

At the time of this writing, there are more than 50 starters at our disposal. Here, we'll list the most common:

spring-boot-starter: core starter, including auto-configuration support, logging, and YAML

spring-boot-starter-app: for aspect-oriented programming with Spring AOP and AspectJ

spring-boot-starter-data-JPA: for using Spring Data JPA with Hibernate

spring-boot-starter-security: for using Spring Security

spring-boot-starter-test: for testing Spring Boot applications

Spring Boot

Trending Blogposts on Spring Boot

Blogpost

Discussion Threads

Interview Questions

Cheatsheets

Technologies

Questionaire

Popular Discussions on Spring Boot

openHow To Implement JWT Authentication In Spring Boot Project?

5

1

0

openHow To Implement OAuth In Spring Boot Project?

6

1

1

PRODUCTS

QUICK LINKS

LEGAL

Spring Boot

Trending Blogposts on Spring Boot

Blogpost

Discussion Threads

Interview Questions

Cheatsheets

Technologies

Questionaire

Popular Discussions on Spring Boot

openHow To Implement JWT Authentication In Spring Boot Project?

5

1

0

openHow To Implement OAuth In Spring Boot Project?

6

1

1

Spring BootWatch

Trending Blogposts on Spring Boot

Blogpost

Discussion Threads

Interview Questions

Cheatsheets

Technologies

Questionaire

Popular Discussions on Spring Boot

openHow To Implement JWT Authentication In Spring Boot Project?

5

1

0

openHow To Implement OAuth In Spring Boot Project?

6

1

1

PRODUCTS

QUICK LINKS

LEGAL

Spring BootWatch

Trending Blogposts on Spring Boot

Blogpost

Discussion Threads

Interview Questions

Cheatsheets

Technologies

Questionaire

Popular Discussions on Spring Boot

openHow To Implement JWT Authentication In Spring Boot Project?

5

1

0

openHow To Implement OAuth In Spring Boot Project?

6

1

1

Spring Boot

Spring Boot