Interview Preparation J2EE & Spring, Spring Boot - Yash-777/MyWorld GitHub Wiki

Uniform Resource Locators (URLs)

The Hypertext Transfer Protocol (HTTP) is designed to enable communications between clients and servers

A URL (Uniform Resource Locator) is the address of a unique resource on the internet. It is one of the key mechanisms used by browsers to retrieve published resources, such as HTML pages, CSS documents, images, and so on. The Web Storage API extends the Window object with two new properties — Window.sessionStorage and Window.localStorage. — invoking one of these will create an instance of the Storage object, through which data items can be set, retrieved, and removed. A different Storage object is used for the sessionStorage and localStorage for each origin (domain). Document.cookie The Document property cookie lets you read and write cookies associated with the document. It serves as a getter and setter for the actual values of the cookies. localStorage.setItem('colorSetting', '#a4509b'); document.cookie = "yummy_cookie=choco";

The HTTP/1.0 specification defined the GET, HEAD and POST methods and the HTTP/1.1 specification added five new methods: OPTIONS, PUT, DELETE, TRACE and CONNECT. HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes: Informational responses (100 – 199) Successful responses (200 – 299) Redirection messages (300 – 399) Client error responses (400 – 499) Server error responses (500 – 599) 👉 Example @RequestMapping(value = "/user/{id}", method = RequestMethod.GET) public ResponseEntity getUser(@PathVariable Long id) { return Optional .ofNullable( userRepository.findOne(id) ) .map( user -> ResponseEntity.ok().body(user) ) //200 OK .orElseGet( () -> ResponseEntity.notFound().build() ); //404 Not found }

HTTP Request & Response (Object Marshalling, unmarshalling)? In HTTP communication, marshalling converts Java objects to JSON/XML for requests, and unmarshalling converts responses back to Java objects.

Is marshalling the same as serialization? Serialization is Java-specific; marshalling is broader and used in HTTP, REST, and RPC.

Servlet lifecycle methods (init, service, destroy, getservletconfig, getservlet)

public abstract interface Servlet {
  public abstract void init(ServletConfig paramServletConfig) throws ServletException;
  public abstract ServletConfig getServletConfig();
  public abstract void service(ServletRequest paramServletRequest, ServletResponse paramServletResponse)
    throws ServletException, IOException;
  public abstract String getServletInfo();
  public abstract void destroy();
}

By default, a web server (or servlet container) creates only one instance of a servlet. When multiple requests arrive for that servlet, each request is processed by a separate thread.
These threads are managed by a thread pool provided by the servlet container (for example, Tomcat).

Call we call destroy() inside service() « What will happen? Yes, we can call destroy() from the service() « It will execute the code inside destroy() method, but it will not dispose the servlet object. Servlet get instantiated, disposed by the container.

The servlet container creates a ServletRequest & ServletResponse objects and passes both as an arguments to the servlet's service method.

• To send binary data in a MIME body response, use the ServletOutputStream returned by getOutputStream.
• To send character data, use the PrintWriter object returned by getWriter.

DispatcherServlet is a Spring Framework component, not part of the standard Servlet API. It acts as the front controller in a Spring web application, meaning all incoming HTTP requests first go to the DispatcherServlet.

Using the Servlet API, the DispatcherServlet receives requests from the web container (like Tomcat) and then applies Spring’s web features to process them. It is responsible for:

• Mapping URLs to controller methods
• Invoking the correct handler (@Controller, @RestController)
• Performing data binding and validation
• Handling exceptions centrally
• Resolving views and generating responses

Spring Framework: A massive, powerful toolbox (framework) used to build Java applications. It provides features like Dependency Injection (DI) and Inversion of Control (IoC), but it requires you to set everything up manually.

Spring Boot: An extension of Spring that makes it easy to create "stand-alone, production-grade" applications. It takes away the headache of manual configuration. (simplifying configuration is one of the key goals)
Spring Boot Starter Parent Parent pom providing dependency and plugin management for applications built with Maven.

Spring Boot simplifies Spring by providing auto-configuration, embedded servers, and faster application setup.

Bean: All the objects created by spring container and stores/manages by IOC is called Spring Bean

What is IoC (Inversion of Control)?

Inversion of Control is a design principle where the control of object creation and dependency management is shifted from the program to a container/framework.

👉 Instead of creating objects manually, Spring handles object creation and lifecycle. We only provide configuration information to Spring about how an object should be created and managed.

• If a bean has dependencies, Spring ensures those dependencies are created and injected first using @Autowired.
• If the dependency is marked as @Lazy, Spring injects a proxy and creates the actual object only when it is first used.

class Car {
    Engine engine = new Engine(); // tightly coupled
}
      

class Car {
    Engine engine;
    @Autowored // IOC Creates and Inject dependencies
    Car(Engine engine) {
        this.engine = engine;
    }
}
      

class Car {
    Engine engine = new Engine(); // tightly coupled
}
      

class Car {
    Engine engine;
    @Autowored // IOC Creates and Inject dependencies
    Car(Engine engine) {
        this.engine = engine;
    }
}
      

@Component
class A {
  @Autowired
  B b;   // created before A
}

@Component
class C {
  @Autowired @Lazy
  A a;   // proxy injected, real A created when used
}

🌱 Spring Bean Lifecycle Spring beans are instantiated and managed by the Spring IoC container. Beans are created by providing bean configuration metadata to the container. This configuration metadata can be provided using XML, annotations, or Java-based configuration.

┌─────────────────────────────┐
│ 1. Read Bean Configuration  │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 2. Bean Instantiation       │
│   (new / reflection)        │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 3. Dependency Injection     │
│   (@Autowired, @Value)      │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 4. Aware Interfaces         │
│   BeanNameAware             │
│   BeanFactoryAware          │
│   ApplicationContextAware   │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 5. BeanPostProcessor        │
│   beforeInitialization()    │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 6. Initialization           │
│   @PostConstruct            │
│   afterPropertiesSet()      │
│   custom init-method        │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 7. BeanPostProcessor        │
│   afterInitialization()     │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ 8. Bean Ready to Use        │
└──────────────┬──────────────┘
               ↓
        (Container Shutdown)
               ↓
┌─────────────────────────────┐
│ 9. Destruction Phase        │
│   @PreDestroy               │
│   DisposableBean.destroy()  │
│   custom destroy-method     │
└─────────────────────────────┘
      

package com.example.lifecycle;

import jakarta.annotation.*;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.*;
import org.springframework.stereotype.Component;

@lombok.extern.slf4j.Slf4j @Component
public class BeanLifecycleDemo implements 
        BeanNameAware, BeanFactoryAware, ApplicationContextAware, 
        InitializingBean, DisposableBean, SmartInitializingSingleton {

   {
      // Why Not Use Instance Block?
      // This runs immediately after constructor call, BEFORE dependencies are injected.
   }

    public BeanLifecycleDemo() {
        log.info("1️⃣ Constructor called — Bean instance created");
    }
    @Override
    public void setBeanName(String name) {
        log.info("2️⃣ BeanNameAware — Bean name set: {}", name);
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.info("3️⃣ BeanFactoryAware — BeanFactory injected");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("4️⃣ ApplicationContextAware — ApplicationContext injected");
    }
    @PostConstruct
    public void postConstruct() {
        log.info("5️⃣ @PostConstruct — Bean fully constructed and dependencies injected");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("6️⃣ InitializingBean — afterPropertiesSet() called");
    }
    @Override
    public void afterSingletonsInstantiated() {
        log.info("7️⃣ SmartInitializingSingleton — All singleton beans are now instantiated");
    }

    @PreDestroy
    public void preDestroy() {
        log.info("8️⃣ @PreDestroy — Pre-destroy method called before bean is destroyed");
    }
    @Override
    public void destroy() throws Exception {
        log.info("8️⃣ DisposableBean — destroy() method called during shutdown");
    }
}

<properties>
    <java.version>17</java.version>
    <resource.delimiter>@</resource.delimiter>
    <maven.compiler.release>${java.version}</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-boot.run.main-class>${start-class}</spring-boot.run.main-class>
</properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
    <archive>
        <manifest>
            <mainClass>${start-class}</mainClass>
            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
        </manifest>
    </archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<configuration>
    <archive>
        <manifest>
            <mainClass>${start-class}</mainClass>
            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
        </manifest>
    </archive>
</configuration>
</plugin>

<!-- Boot LOG:
OptionalLiveReloadServer       : LiveReload server is running on port 35729
LocalDevToolsAutoConfiguration$RestartingClassPathChangeChangedEventListener - Restarting due to 1 class path change (0 additions, 0 deletions, 1 modification)
 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-devtools</artifactId>
	<scope>runtime</scope>
	<optional>true</optional>
</dependency>

@Configuration(proxyBeanMethods = false)
@ConditionalOnInitializedRestarter
@EnableConfigurationProperties(DevToolsProperties.class)
public class LocalDevToolsAutoConfiguration {
   // Local LiveReload configuration.
   @Configuration(proxyBeanMethods = false)
   @ConditionalOnProperty(prefix = "spring.devtools.livereload", name = "enabled", matchIfMissing = true)
   static class LiveReloadConfiguration {

   }

   // Local Restart Configuration.
   @Lazy(false)
   @Configuration(proxyBeanMethods = false)
   @ConditionalOnProperty(prefix = "spring.devtools.restart", name = "enabled", matchIfMissing = true)
   static class RestartConfiguration {

   }
}

[ Code / Classpath Change ]
            │
            ▼
 ┌──────────────────────────┐
 │ Spring Boot DevTools     │
 │ - Detects change         │
 │ - Triggers restart       │
 └────────────┬─────────────┘
              ▼
 ┌──────────────────────────┐
 │ JVM Restart (partial)    │
 │ - ApplicationContext     │
 │   is closed              │
 └────────────┬─────────────┘
              ▼
 ┌──────────────────────────┐
 │ @SpringBootApplication   │
 │ (includes                │
 │  @EnableAutoConfiguration)│
 └────────────┬─────────────┘
              ▼
 ┌──────────────────────────┐
 │ Auto-Configuration Runs  │
 │ - Conditions re-evaluated│
 │ - Beans re-created       │
 └────────────┬─────────────┘
              ▼
 ┌──────────────────────────┐
 │ IoC Container Ready      │
 │ - Embedded Tomcat starts │
 │ - Beans available        │
 └──────────────────────────┘

@SpringBootApplication annotation serves as the entry point for an application : This is a convenience annotation that is equivalent to declaring @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan. It enables auto-configuration, component scanning, and Java-based configuration in a single annotation.

Spring Boot’s auto-configuration mechanism inspects the classpath and automatically configures required beans based on available dependencies. For example:

• If spring-boot-starter-web is present, Spring Boot sets up DispatcherServlet, Tomcat, and other web-related configurations automatically.
• If spring-boot-starter-data-jpa is included, it configures an EntityManagerFactory, DataSource, and TransactionManager. This eliminates most of the boilerplate and lets developers focus on business logic rather than infrastructure setup.

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME)
@Documented @Inherited

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

	// Exclude specific auto-configuration classes/names such that they will never be applied.
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	/**
	 * Base packages to scan for annotated components.
	 * Note: this setting is an alias for @ComponentScan only. It has no effect on @Entityscanning or Spring Data Repository scanning.
	 * For those you should add @EntityScan and @Enable...Repositories annotations.
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

	// The BeanNameGenerator class to be used for naming detected components within the Spring container.
	@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

	/**
	 * Specify whether @Bean methods should get proxied in order to enforce
	 * bean lifecycle behavior, e.g. to return shared singleton bean instances even in
	 * case of direct {@code @Bean} method calls in user code. This feature requires
	 * method interception, implemented through a runtime-generated CGLIB subclass which
	 * comes with limitations such as the configuration class and its methods not being
	 * allowed to declare {@code final}.
	 */
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;

}

@SpringBootApplication
@ComponentScan(basePackages = "com.github.yash777.myworld") // Scans configuration classes of child modules
@ConditionalOnProperty(
    value = "server.app.war.deployment", 
    havingValue = "NO", 
    matchIfMissing = false
)
public class MyApplication {
/**
 * Standard Spring Boot entry point for launching the application with an embedded web server.
 *
 * @param args Command-line arguments passed to the application.
 */
public static void main(String[] args) {
    SpringApplication.run(MyApplication.class, args);
    
    String[] beanNames = ctx.getBeanDefinitionNames();
    Arrays.sort(beanNames);
    for (String beanName : beanNames) {
        System.out.println(beanName);
    }
}

}

@SpringBootApplication
@ComponentScan(basePackages = "com.github.yash777.myworld")
@ConditionalOnProperty(
value = "server.app.war.deployment",
havingValue = "YES",
matchIfMissing = false
)
public class MyApplicationWarDeployment extends SpringBootServletInitializer implements CommandLineRunner {
public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MyApplicationWarDeployment.class);
    Properties props = new Properties();
    
    // Optional: Define any default properties here if needed.
    app.setBannerMode(Mode.CONSOLE); // Show banner in the console
    app.setDefaultProperties(props);
    
    app.run(args);
}

/**
 * This method is executed after the Spring application context is initialized.
 * Use it to perform any post-startup logic or initialization.
 */
@Override
public void run(String... args) throws Exception {
    // Post-startup logic can go here.
}

}

What is @EnableAutoConfiguration?

👉 It tells Spring Boot to automatically configure beans based on:

@Bean
DataSource myDataSource() { ... }

If you need to find out what auto-configuration is currently being applied, and why, start your application with the --debug switch. Doing so enables debug logs for a selection of core loggers and logs a conditions report to the console.

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\

org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration=
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration.AutoConfigureBefore=org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration.ConditionalOnClass=javax.sql.DataSource,org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Dbcp2=
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Dbcp2.ConditionalOnClass=org.apache.commons.dbcp2.BasicDataSource
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Hikari=
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Hikari.ConditionalOnClass=com.zaxxer.hikari.HikariDataSource
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$OracleUcp=
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$OracleUcp.ConditionalOnClass=oracle.jdbc.OracleConnection,oracle.ucp.jdbc.PoolDataSourceImpl
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Tomcat=
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Tomcat.ConditionalOnClass=org.apache.tomcat.jdbc.pool.DataSource

@SuppressWarnings("deprecation")
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@AutoConfigureBefore(SqlInitializationAutoConfiguration.class)
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
		DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class,
		DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {
	
}

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

	private ClassLoader classLoader;

	// Datasource name to use if "generate-unique-name" is false. Defaults to "testdb" when using an embedded database, otherwise null.
	private String name;

	// Fully qualified name of the connection pool implementation to use. By default, it is auto-detected from the classpath.
	private Class<? extends DataSource> type;
	private String driverClassName;
	private String url;
	private String username;
	private String password;
}

Disabling Specific Auto-configuration Classes: If you find that specific auto-configuration classes that you do not want are being applied, you can use the exclude attribute of @SpringBootApplication to disable them, as shown in the following example:

// 1. Exclude in @SpringBootApplication (main class)
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })

// 2. Exclude using @EnableAutoConfiguration
@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class)

// 3. Exclude via application.properties
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

If the class is not on the classpath, you can use the excludeName attribute of the annotation and specify the fully qualified name instead. If you prefer to use @EnableAutoConfiguration rather than @SpringBootApplication, exclude and excludeName are also available. Finally, you can also control the list of auto-configuration classes to exclude by using the spring.autoconfigure.exclude property.

Both JAX-RS and Spring REST support path and query parameters; JAX-RS uses @PathParam and @QueryParam, while Spring uses @PathVariable and @RequestParam, with similar URL semantics but different frameworks.

package javax.ws.rs.*;
@GET
@Path("/orders/{id}")
public String getOrder(
        @PathParam("id") String id,
        @QueryParam("queryParamName") int i) {
    return "Order ID: " + id;
}
      

package org.springframework.web.bind.annotation.*;
@GetMapping("/orders/{id}")
public String getOrder(
        @PathVariable String id,
        @RequestParam("queryParamName") int i) {
    return "Order ID: " + id;
}
      

@Component
class PaypalService implements PaymentService {}
@Component
class StripeService implements PaymentService {}
@Autowired
private PaymentService paymentService;
// ❌ NoUniqueBeanDefinitionException: expected single matching bean but found 2

@Component
@Primary
class PaypalService implements PaymentService {}
@Component
class StripeService implements PaymentService {}
@Autowired
private PaymentService paymentService; // PaypalService injected

@Component("paypal")
class PaypalService implements PaymentService {}
@Component("stripe")
class StripeService implements PaymentService {}
@Autowired
@Qualifier("stripe")
private PaymentService paymentService; // StripeService injected

When should we choose @Primary instead of @Qualifier in Spring applications?

Use @Primary when one implementation should act as the default most of the time. Use @Qualifier when you need explicit control over which bean is injected. In development, @Qualifier is preferred for clarity, while @Primary is convenient for rare or default cases.

• @Primary = “default choice when no qualifier is specified”

@Component
@Primary
@ConditionalOnProperty(
    name = "db.to.use",
    havingValue = "mysql",
    matchIfMissing = true
)
class MySqlRepository implements DataRepository {
}
      

@Component
@ConditionalOnProperty(name = "db.to.use", havingValue = "graphdb")
class GraphDbRepository implements DataRepository {
}
      

What are the differences between @Component, @Controller, @RestController, @Service, and @Repository in Spring, and how do they behave in different layers of an application?

Spring Stereotype Annotations

package org.springframework.stereotype;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
   String value() default "";
}

Domain-Driven Design: Below annotation's serves as a specialization of @Component

@Component
public @interface Controller {
   @AliasFor(annotation = Component.class)
   String value() default "";
}
      

package org.springframework.web.bind.annotation;
@Controller @ResponseBody
public @interface RestController {
   @AliasFor(annotation = Controller.class)
   String value() default "";
}
      

@Component
public @interface Service {
   @AliasFor(annotation = Component.class)
   String value() default "";
}
      

@Component
public @interface Repository {
   @AliasFor(annotation = Component.class)
   String value() default "";
}
      

Spring Boot Actuator provides production-ready endpoints to monitor and manage the health, metrics, and behavior of a running Spring Boot application.

Actuator = Monitor + Manage

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId> <!-- Required for HTTP exposure -->
</dependency>

# Expose Only What You Need
management.endpoints.web.exposure.include=health,info

# Use Separate Port (Recommended)
management.server.port=9090

# Require authentication, Restrict access to admin roles only
management.endpoint.health.show-details=when_authorized

# Disable Dangerous Endpoints
management.endpoint.shutdown.enabled=false

Spring AOP (Aspect-Oriented Programming) allows you to modularize cross-cutting concerns—like logging, security, or transactions—separately from your core business logic.

Spring AOP applies cross-cutting logic to methods using proxies at runtime. 👉 It adds extra behavior to methods without changing the actual code.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
      

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
</dependency>
      

@Configuration
@EnableAspectJAutoProxy
public class AppConfig { }
      

Key components of Aspect-Oriented Programming (AOP):