Spring Framework Interview Questions Flashcards

Question

Can the default web server in the Spring Boot application be disabled?

Answer 1

Yes! application.properties is used to configure the web application type, by mentioning spring.main.web-application-type=none.

Answer 2

Springboot interview question no 13 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/#

Answer 3

https://www.geeksforgeeks.org/aspect-oriented-programming-and-aop-in-spring-framework/

Answer 4

https://www.tutorialspoint.com/springaop/springaop_advice_types.htm https://docs.spring.io/spring-framework/reference/core/aop/ataspectj/advice.html https://www.baeldung.com/spring-aop-advice-tutorial Question 24 from https://www.javatpoint.com/spring-interview-questions

Answer 5

https://www.dineshonjava.com/understanding-aop-proxies-chapter-31/ A proxy pattern is a well-used design pattern where a proxy is an object that looks like another object but adds special functionality to it behind the scenes. Spring AOP follows proxy-based pattern and this is created by the AOP framework to implement the aspect contracts in runtime. The standard JDK dynamic proxies are default AOP proxies that enables any interface(s) to be proxied. Spring AOP can also use CGLIB proxies that are required to proxy classes, rather than interfaces. In case a business object does not implement an interface, then CGLIB proxies are used by default.

Answer 6

https://www.geeksforgeeks.org/spring-jdbc-template/ Spring JDBC question 4 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/#

Answer 7

Spring JDBC question 5 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/# Question 15 from https://www.javatpoint.com/spring-interview-questions

Answer 8

https://www.geeksforgeeks.org/spring-mvc-framework/ SpringMVC framework question 1 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/#

Answer 9

https://www.upgrad.com/blog/spring-mvc-flow-diagram/#:~:text=Fast%20development%3A%20The%20MVC%20spring,for%20application%20and%20framework%20classes.

Answer 10

https://www.geeksforgeeks.org/spring-mvc-framework/

Answer 11

https://www.geeksforgeeks.org/viewresolver-in-spring-mvc/

Answer 12

https://www.geeksforgeeks.org/spring-controller-annotation-with-example/

Answer 13

https://www.geeksforgeeks.org/spring-controller-annotation-with-example/

Answer 14

https://stackoverflow.com/questions/72211755/when-to-use-controller-and-when-restcontroller-annotation-in-restapi-based-on#:~:text=%40Controller%20is%20used%20to%20annotate,expect%20from%20that%20particular%20endpoint. @Controller Map of the model object to view or template and make it human readable but @RestController simply returns the object and object data is directly written in HTTP response as JSON or

Answer 15

Yes! You can create a controller without @Controller or @RestController annotations by annotating the Spring MVC Controller classes using the @Component annotation. In this case, the real job of request mapping to handler method is done using the @RequestMapping annotation. https://stackoverflow.com/questions/29410179/how-can-i-create-a-spring-controller-without-the-use-of-the-annotations Yes, you can create a controller in Spring without using the @Controller or @RestController annotations. The @Controller and @RestController annotations are just convenience annotations that provide specific functionalities, but you can achieve the same functionality by using other annotations or configuration. To create a controller without using @Controller or @RestController, you can use the following approach: Implement the Controller Logic: Create a regular Java class that contains the logic for handling HTTP requests and generating responses. Use Appropriate Annotations: Instead of @Controller or @RestController, you can use other annotations to specify the request mappings and the response type.

Answer 16

https://stackoverflow.com/questions/11815339/role-purpose-of-contextloaderlistener-in-spring The ContextLoaderListener loads and creates the ApplicationContext, so a developer need not write explicit code to do create it. In short, it is a listener that aids to bootstrap Spring MVC. The application context is where Spring bean resides. For a web application, there is a subclass called WebAppliationContext. The lifecycle of the ApplicationContext is tied to the lifecycle of the ServletContext by using ContextLoaderListener. The ServletContext from the WebApplicationContext can be obtained using the getServletContext() method

Answer 17

https://medium.com/javarevisited/difference-between-requestparam-and-pathvariable-in-spring-mvc-873bd6330bce#:~:text=%40RequestParam%20captures%20values%20from%20the,slashes%20(%E2%80%9C%2F%E2%80%9D).

Answer 18

Model is a reference to have the data for rendering. It is always created and passed to the view in Spring MVC. If a mapped controller method has Model as a parameter, then that model instance is automatically injected to that method. Any attributes set on the injected model would be preserved and passed to the View. In the context of Spring MVC, the term “Model” represents the data layer. It is a map (similar to a java.util.Map) that contains data to be rendered by the View. This data is typically the outcome of executing your business logic, which you want to show to the user.

Answer 19

https://www.digitalocean.com/community/tutorials/spring-autowired-annotation#:~:text=Spring%20%40Autowired%20annotation%20is%20used,through%20spring%20bean%20configuration%20file.

Answer 20

The annotation plays a very important role in binding method parameters to the respective attribute that corresponds to a model. Then it reflects the same on the presentation page. The role of the annotation also depends on what the developer is using that for. In case, it is used at the method level, then that method is responsible for adding attributes to it. When used at a parameter level, it represents that the parameter value is meant to be retrieved from the model layer. https://www.geeksforgeeks.org/spring-mvc-modelattribute-annotation-with-example/ The @ModelAttribute annotation in Spring MVC is used to bind method parameters or method return values to model attributes. It plays a crucial role in the Model-View-Controller (MVC) architecture, where it helps transfer data between the Controller and the View. The key role of @ModelAttribute is to facilitate data transfer between the Controller and the View. It allows you to pre-populate form data when displaying forms to users and automatically bind user inputs to model attributes when processing form submissions. Additionally, it helps in adding common attributes (like reference data) to the model across multiple controller methods.

Answer 21

https://stackoverflow.com/questions/5837122/can-someone-explain-the-spring-web-xml-file web.xml is also known as the Deployment Descriptor which has definitions of the servlets and their mappings, filters, and lifecycle listeners. It is also used for configuring the ContextLoaderListener. Whenever the application is deployed, a ContextLoaderListener instance is created by Servlet container which leads to a load of WebApplicationContext.

Answer 22

https://www.codingninjas.com/studio/library/spring-dependency-injection#:~:text=The%20different%20types%20of%20dependency%20injections%20in%20Spring%20are%20constructor,according%20to%20the%20different%20requirements.

Answer 23

https://stackoverflow.com/questions/29413290/how-exactly-works-the-spring-session-scope-of-a-bean-what-is-the-default-scope SpringMVC Interview question 14 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/#

Answer 24

https://www.linkedin.com/pulse/spring-boot-important-annotations-abid-anjum?utm_source=share&utm_medium=member_ios&utm_campaign=share_via https://stackoverflow.com/questions/16769360/how-does-required-annotation-work-with-javaconfig The annotation is used for indicating that the property of the bean should be populated via autowiring or any explicit value during the bean definition at the configuration time.

Answer 25

Spring MVC Interview question 16 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/#

Answer 26

No, the singleton beans are not thread-safe because the concept of thread-safety essentially deals with the execution of the program and the singleton is simply a design pattern meant for the creation of objects. Thread safety nature of a bean depends on the nature of its implementation.

Answer 27

The thread safety can be achieved by changing the scope of the bean to request, session or prototype but at the cost of performance. This is purely based on the project requirements.

Answer 28

@Repository annotation indicates that a component is used as the repository that acts as a means to store, search or retrieve data. These can be added to the DAO classes. https://medium.com/@AlexanderObregon/understanding-the-role-of-the-repository-annotation-in-spring-data-access-95ec917c77b0#:~:text=The%20%40Repository%20annotation%20simplifies%20exception,thrown%20by%20the%20DAO%20layer.

Answer 29

https://www.geeksforgeeks.org/what-is-dispatcher-servlet-in-spring/ The dispatcher servlet is instantiated by means of servlet containers such as Tomcat. The Dispatcher Servlet should be defined in web.xml The DispatcherServlet is instantiated by Servlet containers like Tomcat.

Answer 30

The root application context is loaded using the ContextLoaderListener that belongs to the entire application. Spring MVC allows instantiating multiple DispatcherServlet and each of them have multiple contexts specific to them. They can have the same root context too.

Answer 31

A Dispatcher Servlet knows which controller to call by means of handler mappings. These mappings have the mapping between the controller and the requests. BeanNameUrlHandlerMapping and SimpleUrlHandlerMapping are the two most commonly used handler mappings. BeanNameUrlHandlerMapping: When the URL request matches the bean name, the class corresponding to the bean definition is the actual controller that is responsible for processing the request. SimpleUrlHandlerMapping: Here, the mapping is very explicit. The number of URLs can be specified here and each URL is associated explicitly with a controller. If the Spring MVC is configured using annotations, then @RequestMapping annotations are used for this purpose. The @RequestMapping annotation is configured by making use of the URI path, HTTP methods, query parameters, and the HTTP Headers.

Answer 32

The view requires access to the model to render the output as the model contains the required data meant for rendering. The model is associated with the controller that processes the client requests and finally encapsulates the response into the Model object.

Answer 33

https://stackoverflow.com/questions/10413886/what-is-the-use-of-bindingresult-interface-in-spring-mvc#:~:text=%5B%20BindingResult%20%5D%20is%20Spring's%20object%20that,object%20and%20throw%20an%20exception.

Answer 34

https://www.geeksforgeeks.org/spring-boot-interceptor/#:~:text=Spring%20Boot%20Interceptor%20is%20an,an%20incoming%20or%20outgoing%20request%E2%80%9D.

Answer 35

The spring-mv.jar does not belong to the spring-core. This means that the jar has to be included in the project’s classpath if we have to use the Spring MVC framework in our project. For Java applications, the spring-mvc.jar is placed inside /WEB-INF/lib folder. The spring-mvc.jar file is not part of the spring-core library, and they serve different purposes. spring-core: This is the core Spring framework, which provides fundamental parts of the framework such as dependency injection and inversion of control. spring-webmvc: This is the Spring MVC framework (typically named as spring-webmvc.jar not spring-mvc.jar), which is built on top of the core Spring framework and provides Model-View-Controller (MVC) architecture for building web applications. So, if you’re building an application using the Spring MVC framework, you would need both spring-core and spring-webmvc on your classpath. These libraries are usually managed by a build tool like Maven or Gradle, and are automatically included when you specify them as dependencies in your build file.

Answer 36

is used for activating applied annotations in pre-registered beans in the application context. It also registers the beans defined in the config file and it scans the annotations within the beans and activates them. The tag does the task of along with scanning the packages and registering the beans in the application context. = Scan and activate annotations in pre-registered beans. = Register Bean + Scan and activate annotations in package. context:annotation-config>: This is used to activate various annotations within Spring-managed beans. For example, if you have beans that are manually defined in your XML file and these beans have annotations like @Autowired, @PostConstruct, @PreDestroy, @Resource, etc., you need to activate these annotations. However, it does not automatically detect and instantiate beans from the classpath. : This tag does everything that does, but it goes one step further. It scans the classpath for classes annotated with @Component, @Service, @Repository, @Controller, etc., and automatically registers them as beans in the Spring application context. In other words, it automatically detects and instantiates your beans. So, when you use , you don’t need to explicitly define each bean in your XML configuration file, as long as they are annotated correctly and exist within the base-package specified by .

Answer 37

Spring MVC interview question 28 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/# Question 40 from https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 38

This can be done by either implementing the spring-aware interfaces or by using the @Autowired annotation. @Autowired private ServletContext servletContext; @Autowired private ServletConfig servletConfig; Question 19 from https://www.baeldung.com/spring-interview-questions#Q17

Answer 39

https://www.geeksforgeeks.org/spring-difference-between-beanfactory-and-applicationcontext/ Question 42 from https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 40

Spring MVC framework question 31 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/# Internationalization (i18n) and localization (L10n) are important features for applications that need to support multiple languages or locales. In Spring MVC, these are supported using a combination of LocaleResolver, LocaleChangeInterceptor, and message source properties files.

Answer 41

Spring MVC interview question 32 https://www.interviewbit.com/spring-interview-questions/?sign_up_medium=ib_article_auth_blocker/# MultipartResolver is an interface defined in Spring MVC framework that is used for uploading files. When a form in a Spring web application is submitted and it has enctype=”multipart/form-data”, the MultipartResolver implementation handles the file upload part of the request. The MultipartResolver is part of the Spring DispatcherServlet’s configuration, so you’ll define it in your Spring configuration.

Answer 42

To use the servlet container which is configured in the JNDI (Java Naming and Directory Interface) DataSource, the DataSource bean has to be configured in the spring bean config file and then injected into the beans as dependencies. Post this, the DataSource bean can be used for performing database operations by means of the JdbcTemplate. The syntax for registering a MySQL DataSource bean: To use a Tomcat JNDI DataSource in a Spring application: Setup DataSource in Tomcat: Configure the DataSource in Tomcat’s context.xml file with the necessary parameters (username, password, driverClassName, etc).

Answer 43

The validation is generally performed during HTTP POST requests. During HTTP requests, if the state of the checkbox is unchecked, then HTTP includes the request parameter for the checkbox thereby not picking up the updated selection. This can be fixed by making use of a hidden form field that starts with _ in the Spring MVC.

Answer 44

https://data-flair.training/blogs/advantages-of-spring/

Answer 45

https://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/html/overview.html https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 46

https://www.geeksforgeeks.org/spring-understanding-inversion-of-control-with-example/

Answer 47

Singleton scope should be used with EJB stateless session bean and prototype scope with EJB stateful session bean.

Answer 48

https://www.javatpoint.com/stateless-session-bean

Answer 49

https://www.interviewbit.com/blog/stateful-vs-stateless/

Answer 50

https://www.tutorialspoint.com/spring/spring_transaction_management.htm#:~:text=Spring%20supports%20both%20programmatic%20and,need%20of%20an%20application%20server.

Answer 51

https://www.javatpoint.com/spring-JdbcTemplate-tutorial#:~:text=Advantage%20of%20Spring%20JdbcTemplate&text=Spring%20JdbcTemplate%20eliminates%20all%20the,lot%20of%20work%20and%20time. Question 13 from https://www.javatpoint.com/spring-interview-questions

Answer 52

https://prateek-ashtikar512.medium.com/spring-jdbc-namedparameterjdbctemplate-2e7cd08c49e6

Answer 53

https://docs.spring.io/spring-framework/docs/2.5.x/reference/jdbc.html#:~:text=SimpleJdbcTemplate%20%2D%20this%20class%20combines%20the,an%20easier%20to%20use%20API. Question 17 from https://www.javatpoint.com/spring-interview-questions

Answer 54

https://medium.com/@AlexanderObregon/cross-cutting-concerns-in-spring-microservices-with-aspect-oriented-programming-aop-de72c52e7639 https://www.jbktutorials.com/spring-aop/advantages-of-spring-aop.php#gsc.tab=0

Answer 55

https://docs.spring.io/spring-framework/docs/2.0.x/reference/aop.html#:~:text=Join%20point%3A%20A%20point%20during,always%20represents%20a%20method%20execution.

Answer 56

No, spring framework supports method execution joinpoint only.

Answer 57

https://www.tutorialspoint.com/springaop/springaop_pointcut_methods1.htm https://docs.spring.io/spring-framework/reference/core/aop/ataspectj/pointcuts.html

Answer 58

https://www.digitalocean.com/community/tutorials/spring-aop-example-tutorial-aspect-advice-pointcut-joinpoint-annotations#:~:text=Aspect%3A%20An%20aspect%20is%20a,as%20Aspect%20using%20%40Aspect%20annotation.

Answer 59

Introduction represents introduction of new fields and methods for a type.

Answer 60

https://stackoverflow.com/questions/56692011/what-is-a-target-object-in-spring-aop

Answer 61

https://www.simplilearn.com/tutorials/spring-tutorial/spring-aop-aspect-oriented-programming#:~:text=Weaving%3A,normally%20performs%20weaving%20at%20runtime.

Answer 62

No, spring framework performs weaving at runtime.

Answer 63

There are 3 AOP implementation. Spring AOP Apache AspectJ JBoss AOP

Answer 64

https://www.javatpoint.com/spring-mvc-tutorial#:~:text=Front%20Controller%20%2D%20In%20Spring%20Web,of%20the%20Spring%20MVC%20application. https://www.geeksforgeeks.org/spring-mvc-framework/

Answer 65

https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-validation.html#:~:text=Spring%20MVC%20has%20built%2Din,support%20works%20on%20two%20levels.

Answer 66

The recommended approach is to use constructor arguments for mandatory dependencies and setters for optional ones. This is because constructor injection allows injecting values to immutable fields and makes testing easier.

Answer 67

By default, a Spring Bean is initialized as a singleton.

Answer 68

Question 12 from https://www.baeldung.com/spring-interview-questions#Q6

Answer 69

It’s one of the ways of configuring Spring-based applications in a type-safe manner. It’s an alternative to the XML-based configuration. https://www.tutorialspoint.com/spring/spring_java_based_configuration.htm

Answer 70

Question 14 from https://www.baeldung.com/spring-interview-questions#Q6

Answer 71

https://spring.io/projects/spring-security/

Answer 72

https://medium.com/@bubu.tripathy/design-patterns-used-in-spring-framework-60df94fd3400

Answer 73

https://stackoverflow.com/questions/21969044/when-to-use-spring-prototype-scope Question 18 from https://www.baeldung.com/spring-interview-questions#Q17

Answer 74

The @RequestMapping annotation is used to map web requests to Spring Controller methods. In addition to simple use cases, we can use it for mapping of HTTP headers, binding parts of the URI with @PathVariable, and working with URI parameters and the @RequestParam annotation.

Answer 75

Question 22 from https://www.baeldung.com/spring-interview-questions#Q17

Answer 76

There are two distinct ways to configure Transactions — with annotations or by using Aspect-Oriented Programming (AOP) — each with their advantages. Here are the benefits of using Spring Transactions, according to the official docs: Provide a consistent programming model across different transaction APIs such as JTA, JDBC, Hibernate, JPA and JDO Support declarative transaction management Provide a simpler API for programmatic transaction management than some complex transaction APIs such as JTA Integrate very well with Spring’s various data access abstractions

Answer 77

https://docs.spring.io/spring-framework/reference/data-access/dao.html#:~:text=The%20Data%20Access%20Object%20(DAO,JPA)%20in%20a%20consistent%20way. Question 24 from https://www.baeldung.com/spring-interview-questions#Q17

Answer 78

Question 28 from https://www.baeldung.com/spring-interview-questions#Q24

Answer 79

https://www.digitalocean.com/community/tutorials/spring-webflux-reactive-programming

Answer 80

https://medium.com/javarevisited/difference-between-mono-and-flux-in-spring-webflux-6f260059d199#:~:text=A%20Mono%20is%20a%20reactive,of%20zero%20to%20many%20elements.

Answer 81

https://docs.spring.io/spring-framework/reference/testing/webtestclient.html#:~:text=It%20wraps%20Spring's%20WebClient%20and,server%20request%20and%20response%20objects. https://docs.spring.io/spring-framework/reference/web/webflux-webclient.html

Answer 82

There are some major disadvantages to using reactive streams: Troubleshooting a Reactive application is a bit difficult, so be sure to check out our tutorial on debugging reactive streams for some handy debugging tips. There is limited support for reactive data stores since traditional relational data stores have yet to embrace the reactive paradigm. There’s an extra learning curve when implementing.

Answer 83

In order to take advantage of Java 8 features, the Spring codebase has been revamped. This means older versions of Java cannot be used. So, the framework requires a minimum of Java 8.

Answer 84

As of now, Spring Boot will only allow either Spring MVC or Spring WebFlux, as Spring Boot tries to auto-configure the context depending on the dependencies that exist in its classpath. Also, Spring MVC cannot run on Netty. Moreover, MVC is a blocking paradigm and WebFlux is a non-blocking style. So, we shouldn’t be mixing both together because they serve different purposes.

Answer 85

https://www.turing.com/kb/spring-vs-spring-boots-best-web-apps#:~:text=While%20Spring%20is%20the%20best,the%20simplest%20and%20easiest%20method. Question No 3 from https://www.interviewbit.com/spring-boot-interview-questions/

Answer 86

https://www.geeksforgeeks.org/best-practices-to-secure-microservices-with-spring-security/ https://www.linkedin.com/pulse/spring-microservices-security-best-practices-abid-anjum?utm_source=share&utm_medium=member_ios&utm_campaign=share_via

Answer 87

https://www.digitalocean.com/community/tutorials/key-components-and-internals-of-spring-boot-framework Question No 7 from https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 88

Question No 8 from https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 89

Question No 15 from https://www.edureka.co/blog/interview-questions/spring-interview-questions/

Answer 90

Use Singleton Scope when you want to have only one instance shared across the entire application. Use Prototype Scope when you want a new instance created every time it’s requested, providing independence for each part of the application.

Answer 91

The Spring MVC flow involves several components working together to handle incoming requests and route them to the appropriate controllers for processing. The DispatcherServlet plays a central role in the Spring MVC flow. It receives incoming requests, selects the appropriate controller based on the URL mapping, invokes the controller method to handle the request, prepares the model data and view, resolves the view, and finally sends the response back to the client. The flow is orchestrated through a combination of handler mappings, controllers, view resolvers, and views, allowing Spring MVC to handle various types of requests and produce dynamic responses.

Answer 92

In a Spring application, you can access ServletConfig and ServletContext objects by implementing the ServletContextAware and ServletConfigAware interfaces. These interfaces provide setter methods that Spring will use to inject the necessary objects.

Answer 93

Spring boot provides numbers of starter dependency, here are the most commonly used - Data JPA starter. Test Starter. Security starter. Web starter. Mail starter. Thymeleaf starter. Spring boot starter is a maven template that contains a collection of all the relevant transitive dependencies that are needed to start a particular functionality. Like we need to import spring-boot-starter-web dependency for creating a web application. org.springframework.boot spring-boot-starter-web

Answer 94

https://www.geeksforgeeks.org/spring-boot-starters/#:~:text=Spring%20Boot%20Starters%20are%20dependency,dependencies%20under%20a%20single%20name.

Answer 95

Spring Boot automatically configures your application based on the dependencies you have added to the project by using annotation. The entry point of the spring boot application is the class that contains @SpringBootApplication annotation and the main method. Spring Boot automatically scans all the components included in the project by using @ComponentScan annotation.

Answer 96

Spring Boot application scans all the beans and package declarations when the application initializes. You need to add the @ComponentScan annotation for your class file to scan your components added to your project.

Answer 97

Just like any other Java program, a Spring Boot application must have a main method. This method serves as an entry point, which invokes the SpringApplication#run method to bootstrap the application.

Answer 98

Spring Initializer is a web application that helps you to create an initial spring boot project structure and provides a maven or gradle file to build your code. It solves the problem of setting up a framework when you are starting a project from scratch.

Answer 99

Spring Boot CLI is a command-line interface that allows you to create a spring-based java application using Groovy. Example: You don’t need to create getter and setter method or access modifier, return statement. If you use the JDBC template, it automatically loads for you.

Answer 100

Question 12 from https://www.interviewbit.com/spring-boot-interview-questions/

Answer 101

The primary annotations that Spring Boot offers reside in its org.springframework.boot.autoconfigure and its sub-packages. Here are a couple of basic ones: @EnableAutoConfiguration – to make Spring Boot look for auto-configuration beans on its classpath and automatically apply them. @SpringBootApplication – used to denote the main class of a Boot Application. This annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan annotations with their default attributes. Question 12 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 102

Yes, we can create a non-web application by removing the web dependencies from the classpath along with changing the way Spring Boot creates the application context

Answer 103

Yes, it is possible. By using the server.port in the application.properties.

Answer 104

The default port of the tomcat server-id 8080. It can be changed by adding sever.port properties in the application.property file.

Answer 105

Yes, we can replace the Embedded Tomcat server with any server by using the Starter dependency in the pom.xml file. Like you can use spring-boot-starter-jetty as a dependency for using a jetty server in your project.

Answer 106

Yes, we can use application.properties to configure the web application type i.e spring.main.web-application-type=none.

Answer 107

You can use exclude attribute of @EnableAutoConfiguration if you want auto-configuration not to apply to any specific class. //use of exclude @EnableAutoConfiguration(exclude={className}) https://www.baeldung.com/spring-data-disable-auto-config

Answer 108

Advanced Question 11 from https://www.interviewbit.com/spring-boot-interview-questions/

Answer 109

RequestMapping can be used with GET, POST, PUT, and many other request methods using the method attribute on the annotation. Whereas getMapping is only an extension of RequestMapping which helps you to improve on clarity on request.

Answer 110

While developing the application we deal with multiple environments such as dev, QA, Prod, and each environment requires a different configuration. For eg., we might be using an embedded H2 database for dev but for prod, we might have proprietary Oracle or DB2. Even if DBMS is the same across the environment, the URLs will be different. To make this easy and clean, Spring has the provision of Profiles to keep the separate configuration of environments. Question 26 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 111

https://www.geeksforgeeks.org/spring-boot-actuator/

Answer 112

To enable the spring actuator feature, we need to add the dependency of “spring-boot-starter-actuator” in pom.xml. org.springframework.boot spring-boot-starter-actuator

Answer 113

https://www.geeksforgeeks.org/spring-boot-actuator/ Advanced Question 16 https://www.interviewbit.com/spring-boot-interview-questions/

Answer 114

Spring Boot actuator “/Beans” is used to get the list of all the spring beans in your application.

Answer 115

Spring Boot actuator “/env” returns the list of all the environment properties of running the spring boot application.

Answer 116

Debugging logs can be enabled in three ways - We can start the application with --debug switch. We can set the logging.level.root=debug property in application.property file. We can set the logging level of the root logger to debug in the supplied logging configuration file.

Answer 117

You can define both application and Spring boot-related properties into a file called application.properties. You can create this file manually or use Spring Initializer to create this file. You don’t need to do any special configuration to instruct Spring Boot to load this file, If it exists in classpath then spring boot automatically loads it and configure itself and the application code accordingly.

Answer 118

By leveraging Spring Boot features, users can experience significant advantages over JAX-RS, including: Fast deployment High scalability Container compatibility Minimal configuration Lower production time Increased productivity Reduced development time Easy monitoring and management of applications

Answer 119

Primarily used for developing microservices-based applications, Spring Boot offers the following key features for configuring, developing, and deploying microservices architecture. Integrates a tool called the Actuator, which enables users to manage and monitor applications Provides support for embedded servers, such as Jetty and Tomcat Users can simply run war files, without deploying it Includes an Auto-Configuration functionality, allowing users to configure Spring applications automatically Supports HTTP client Feign

Answer 120

Question 4 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 121

Mentioned below are important Spring Boot dependencies that need to be added to a Gradle-based or Maven-based application, to ensure application compatibility with Spring Boot features.

Answer 122

Question 9 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 123

Question 10 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 124

Spring Boot Properties files are used to configure its auto-configuration and application properties. Spring Boot has many properties that can be used to configure the behavior of the application. Some of the commonly used properties in Spring Boot include server.port, spring.profiles.active, spring.datasource.url, spring.jpa.show-sql, and many more.

Answer 125

Thyme leaf is a popular templating engine used in Spring Boot applications for building dynamic web pages. Moreover, it is humanly readable and developers can use it to create templates that can be rendered in HTML

Answer 126

To use Thymeleaf in a Spring Boot application you should include the thymeleaf-spring-boot-starter dependency in your project.

Answer 127

To connect Spring Boot to a database using JPA, configure the JPA properties in the application.properties or application.yml file.

Answer 128

To connect the Spring Boot to a database using JDBC, configure the JDBC properties in the application.properties or application.yml file.

Answer 129

Follow the steps mentioned below to create a Spring Boot application using the Spring Starter Project Wizard, you need to follow these steps: Open your preferred IDE and select the "New Project" option. Next choose the "Spring Initializr" or "Spring Starter Project" option. Fill in the required project information, such as project name, description, and dependencies. Click on "Generate" to create the project structure and download the necessary dependencies. Start coding your application logic.

Answer 130

Question 24 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 131

https://www.codingninjas.com/studio/library/swagger-in-spring-boot#:~:text=Swagger%20in%20Spring%20Boot%20is,helps%20implement%20the%20API%20specification. Question 25 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 132

Question 27 from https://www.simplilearn.com/spring-boot-interview-questions-article

Answer 133

Question 7 from https://www.turing.com/interview-questions/spring-boot

Answer 134

Question 10 from https://www.turing.com/interview-questions/spring-boot

Answer 135

https://www.turing.com/interview-questions/spring-boot

Answer 136

Question 13 from https://www.turing.com/interview-questions/spring-boot

Answer 137

Question 15 from https://www.turing.com/interview-questions/spring-boot

Answer 138

The SpringApplication.run() method is used to bootstrap and launch a Spring Boot application. It is typically invoked from the main method of the application's entry point class. The run() method initializes the Spring application context, performs auto-configuration, starts the embedded server, and starts the application lifecycle. It returns an instance of the ApplicationContext, allowing access to the application context and its beans.

Answer 139

Question 18 from https://www.turing.com/interview-questions/spring-boot

Answer 140

Question 20 from https://www.turing.com/interview-questions/spring-boot

Answer 141

Question 21 from https://www.turing.com/interview-questions/spring-boot

Answer 142

Question 22 from https://www.turing.com/interview-questions/spring-boot

Answer 143

Question 23 from https://www.turing.com/interview-questions/spring-boot

Answer 144

Question 24 from https://www.turing.com/interview-questions/spring-boot

Answer 145

Question 26 from https://www.turing.com/interview-questions/spring-boot

Answer 146

Question 27 from https://www.turing.com/interview-questions/spring-boot

Answer 147

Question 28 from https://www.turing.com/interview-questions/spring-boot

Answer 148

Question 29 from https://www.turing.com/interview-questions/spring-boot

Answer 149

Question 30 from https://www.turing.com/interview-questions/spring-boot

Answer 150

Question 31 from https://www.turing.com/interview-questions/spring-boot

Answer 151

Question 32 from https://www.turing.com/interview-questions/spring-boot

Answer 152

The @Profile annotation is used to activate or deactivate specific configuration components or beans based on the current environment or profile in a Spring Boot application. Annotating a class or method with @Profile and specifying the desired profile name lets you control when that component or bean should be active. This allows you to have different configurations for different deployment environments such as development, testing, or production.

Answer 153

Question 34 from https://www.turing.com/interview-questions/spring-boot

Answer 154

Question 35 from https://www.turing.com/interview-questions/spring-boot

Answer 155

Question 37 from https://www.turing.com/interview-questions/spring-boot

Answer 156

Question 38 from https://www.turing.com/interview-questions/spring-boot

Answer 157

Question 39 from https://www.turing.com/interview-questions/spring-boot

Answer 158

Question 40 from https://www.turing.com/interview-questions/spring-boot

Answer 159

Intermediate Question 3 from https://www.turing.com/interview-questions/spring-boot

Answer 160

Spring Boot provides excellent support for database operations through its integration with Spring Data JPA. By defining entities and repositories, you can perform CRUD (Create, Read, Update, Delete) operations on databases with minimal boilerplate code. Spring Boot automatically configures the database connection and transaction management, and provides powerful querying capabilities.

Answer 161

Caching in a Spring Boot application can be implemented using the @Cacheable, @CacheEvict, and other cache-related annotations provided by the Spring Framework. Adding these annotations to methods lets you cache the results and improve performance. Spring Boot integrates with popular caching providers like Ehcache, Hazelcast, and Redis.

Answer 162

To enable CORS in a Spring Boot application, you can use the @CrossOrigin annotation at the controller level or globally configure CORS using a WebMvcConfigurer bean. The annotation allows you to specify the allowed origins, HTTP methods, headers, and other CORS-related settings. Enabling CORS ensures that web browsers can make requests to your application from different domains.

Answer 163

Intermediate Question 11 from https://www.turing.com/interview-questions/spring-boot

Answer 164

Intermediate Question 12 from https://www.turing.com/interview-questions/spring-boot

Answer 165

Intermediate Question 16 from https://www.turing.com/interview-questions/spring-boot

Answer 166

Intermediate Question 16 from https://www.turing.com/interview-questions/spring-boot

Answer 167

Intermediate Question 17 from https://www.turing.com/interview-questions/spring-boot

Answer 168

intermediate Question 18 https://www.turing.com/interview-questions/spring-boot

Answer 169

Intermediate Question 19 https://www.turing.com/interview-questions/spring-boot

Answer 170

Intermediate Question 20 https://www.turing.com/interview-questions/spring-boot

Answer 171

Intermediate Question 21 https://www.turing.com/interview-questions/spring-boot

Answer 172

Intermediate Question 22 https://www.turing.com/interview-questions/spring-boot

Answer 173

The @Conditional annotation in Spring Boot allows you to conditionally activate or deactivate beans or configurations based on specific conditions. By annotating a bean or configuration class with @Conditional and providing a condition class implementing the Condition interface, you can control whether the bean or configuration should be created and registered based on runtime conditions. This enables flexible configuration based on environment, properties, or other factors.

Answer 174

The @SpringBootTest annotation is used to bootstrap a Spring Boot application context for testing purposes. It allows you to load the entire application context, including all configurations and beans, during integration tests. @SpringBootTest provides features like auto-configuration, dependency injection, and easy access to application-specific components, enabling comprehensive testing of Spring Boot applications.

Answer 175

Spring Boot's actuator health checks are endpoints provided by the Actuator that give insights into the application's health. By default, health indicators check the overall system health. You can customize them by implementing the HealthIndicator interface and registering them with the application context. Custom health indicators allow you to monitor specific aspects of the application's health such as database connectivity, external service availability, or custom health checks.

Answer 176

You can secure REST APIs in a Spring Boot application using JSON Web Tokens (JWT) by integrating Spring Security and JWT libraries. Spring Security provides mechanisms for authentication and authorization, while JWT facilitates token-based authentication. By configuring Spring Security filters, implementing authentication and authorization providers, and validating JWT tokens, you can protect your REST APIs and control access based on user roles and permissions.

Answer 177

The @EntityScan annotation is used to specify the base packages to scan for entity classes in a Spring Boot application. When using JPA (Java Persistence API) with Spring Boot, @EntityScan helps the JPA provider locate and manage entity classes. By default, Spring Boot scans the package of the application's main class and its sub-packages. However, if entity classes are located in different packages, you need to use @EntityScan to include those packages.

Answer 178

The @Retryable annotation is used to specify that a method should be retried if it fails due to specified exceptions. Adding @Retryable and configuring the desired retry behavior enables Spring Boot to automatically retry the method when exceptions occur. This can be useful for handling transient errors, such as network timeouts or temporary resource unavailability, and ensuring the successful execution of critical operations.

Answer 179

Auto-reconfiguration in Spring Boot is a feature that automatically configures certain components and dependencies based on the classpath and available resources. It simplifies the configuration process by detecting and configuring components like data sources, messaging brokers, and caches. Auto-reconfiguration has limitations when it comes to complex or custom configurations. It may not always provide the desired configuration out of the box. In such cases, manual configuration may be required.

Answer 180

To implement distributed caching in a Spring Boot application with Hazelcast or Redis, you can leverage the respective cache providers' integration libraries. Configuring the cache manager and cache-related settings lets you enable distributed caching. Spring Boot simplifies the setup and configuration process by providing auto-configuration support for both Hazelcast and Redis. Additionally, you can annotate methods with cache-related annotations like @Cacheable or @CacheEvict to cache and retrieve data efficiently.

Answer 181

Advanced Question 1 https://www.turing.com/interview-questions/spring-boot

Answer 182

To customize the default error pages in a Spring Boot application, you can create an error page template or controller method that handles the error. Defining an error template with the appropriate name and placing it in the src/main/resources/templates/error directory enables Spring Boot to automatically render that template for the corresponding error status code. Alternatively, you can create a controller method with @ExceptionHandler annotation to handle specific exceptions and return a custom error response.

Answer 183

Advanced Question 3 https://www.turing.com/interview-questions/spring-boot

Answer 184

Advanced Question 5 https://www.turing.com/interview-questions/spring-boot

Answer 185

Advanced Question 6 https://www.turing.com/interview-questions/spring-boot

Answer 186

Spring Boot provides integration with messaging systems like RabbitMQ through the Spring AMQP project. To integrate RabbitMQ with a Spring Boot application, you can include the spring-boot-starter-amqp dependency and configure the necessary properties in the application's configuration file (application.properties or application.yml). You can use the RabbitTemplate class to send messages to RabbitMQ and consume messages using @RabbitListener annotations on appropriate methods.

Answer 187

Advanced Question 8 https://www.turing.com/interview-questions/spring-boot

Answer 188

To handle large file uploads in a Spring Boot application, you can configure the maximum file size limit in the application's properties file by setting the spring.servlet.multipart.max-file-size and spring.servlet.multipart.max-request-size properties to appropriate values. Additionally, you can use the MultipartFile parameter in the controller method to receive the uploaded file and process it as needed.

Answer 189

Spring Boot Actuator endpoints provide insights into the internals of a Spring Boot application such as health status, metrics, environment information, and more. These endpoints expose management and monitoring capabilities over HTTP or other protocols, allowing you to monitor and manage the application in production. Actuator endpoints can be customized and secured based on the specific requirements of the application.

Answer 190

Spring Boot Actuator metrics allow you to collect and monitor various application metrics such as HTTP request counts, response times, JVM memory usage, and database connection pool metrics. Actuator metrics are collected by integrating with metrics libraries like Micrometer and can be exposed through various endpoints such as /actuator/metrics. These metrics can be visualized using monitoring tools like Prometheus, Grafana, or the built-in Actuator endpoints.

Answer 191

Advanced Question 12 https://www.turing.com/interview-questions/spring-boot

Answer 192

The Spring Cloud Netflix stack provides integration with various Netflix OSS components to simplify the development of distributed systems in a Spring Boot application. It includes modules like Eureka for service discovery, Ribbon for client-side load balancing, Hystrix for fault tolerance, and Zuul for API gateway functionality. These components enable developers to build scalable and resilient microservices architectures by providing out-of-the-box solutions for common distributed system challenges.

Answer 193

Spring Boot DevTools is a set of developer tools that enhance the development experience for Spring Boot applications. It provides features like automatic application restart on code changes, live reloading of static resources, and enhanced logging during development. DevTools helps in reducing the development turnaround time by eliminating the need for manual restarts and providing quick feedback on code changes.

Answer 194

To implement distributed tracing in a Spring Boot application with Spring Cloud Sleuth, you can include the necessary dependencies like spring-cloud-starter-sleuth. Sleuth integrates with popular distributed tracing systems like Zipkin or Jaeger. Once configured, Sleuth automatically adds trace and span identifiers to the application's logs and propagates them across different services. This allows you to trace the flow of requests across multiple services and analyze performance bottlenecks.

Answer 195

Advanced Question 16 https://www.turing.com/interview-questions/spring-boot

Answer 196

Spring Boot provides integration with Apache Kafka through the Spring Kafka project. You can include the spring-boot-starter-kafka dependency to get started. Spring Kafka provides abstractions to produce and consume messages from Kafka topics using the KafkaTemplate and @KafkaListener annotations, respectively. Additionally, Spring Kafka integrates with Spring Boot's auto-configuration to simplify the configuration of Kafka-related properties.

Answer 197

Spring Boot's caching abstraction provides a convenient way to cache the results of expensive operations, reducing the response time and improving application performance. By using annotations like @Cacheable, @CachePut, and @CacheEvict, you can easily cache method results based on specified cache names or keys. The caching abstraction supports various cache providers, such as Redis or Ehcache, and can be easily configured using the application's properties file.

Answer 198

Include corresponding dependencies (flyway-core or liquibase-core) to perform database migrations in a Spring Boot application using Flyway or Liquibase. By placing the migration scripts in the classpath (src/main/resources/db/migration), Flyway or Liquibase will automatically execute the scripts during application startup. These migration scripts allow you to manage database schema changes, versioning, and data initialization in a controlled manner.

Answer 199

Externalized configuration in Spring Boot allows you to configure the application using external properties files, environment variables, or command-line arguments. This approach decouples the application configuration from the code, making it more flexible and easier to manage. The externalized configuration enables the application to be deployed in different environments without modifying the code. Spring Boot provides a standardized and flexible way to read and use these external configurations.

Answer 200

Advanced Question 21 https://www.turing.com/interview-questions/spring-boot

Answer 201

You can use the spring-cloud-function-adapter-aws dependency to implement serverless functions using Spring Boot and AWS Lambda. You can deploy Spring Boot applications as serverless functions on AWS Lambda by creating a function bean and configuring the AWS Lambda handler. The adapter takes care of the integration between Spring Cloud Function and AWS Lambda, allowing you to develop serverless functions using the familiar Spring Boot programming model.

Answer 202

Advanced Question 23 https://www.turing.com/interview-questions/spring-boot

Answer 203

Advanced Question 24 https://www.turing.com/interview-questions/spring-boot

Answer 204

You can use the Spring Security OAuth2 module to integrate Spring Boot with OAuth 2.0. By configuring the appropriate OAuth 2.0 provider details and defining the client registration properties, Spring Boot can handle the authentication and authorization flow. You can secure your endpoints by applying Spring Security annotations like @PreAuthorize or by using declarative configuration. This integration enables secure authentication and authorization using OAuth 2.0 standards.

Answer 205

Advanced Question 26 https://www.turing.com/interview-questions/spring-boot

Answer 206

Advanced Question 27 https://www.turing.com/interview-questions/spring-boot

Answer 207

To implement distributed tracing in a Spring Boot application using OpenTelemetry, you can include the necessary OpenTelemetry dependencies such as open telemetry-API and an OpenTelemetry exporter. Configuring the exporter lets you send trace data to a distributed tracing system like Jaeger or Zipkin. OpenTelemetry automatically instructs the application to capture and propagate trace information across different services, allowing you to trace the execution path of requests in a distributed system.

Answer 208

Advanced Question 29 https://www.turing.com/interview-questions/spring-boot

Answer 209

Advanced Question 30 https://www.turing.com/interview-questions/spring-boot