10+ Planet Spark Interview Questions and Answers

Constructor injection passes dependencies through a class constructor, while setter injection uses setter methods.

• Constructor injection is done by passing dependencies as parameters to the constructor.

• Setter injection involves calling setter methods to set the dependencies after the object is created.

• Constructor injection ensures that all required dependencies are provided at the time of object creation.

• Setter injection allows for optional dependencies to be set after the obj...read more

Entity instances can be in new, managed, detached, or removed states.

• New state: when an entity is first created but not yet associated with a persistence context.

• Managed state: when an entity is being managed by a persistence context and any changes made to it will be tracked.

• Detached state: when an entity was previously managed but is no longer associated with a persistence context.

• Removed state: when an entity is marked for removal from the database.

Design patterns in Java provide reusable solutions to common problems, improving code quality and maintainability.

• Promotes code reusability by providing proven solutions to common design problems

• Improves code maintainability by following established best practices

• Enhances code readability by providing a common language for developers to communicate design ideas

• Helps in creating scalable and flexible software architecture

• Examples include Singleton, Factory, Observer, and Strat...read more

Types of advice in Spring AOP include before, after, around, after-returning, and after-throwing.

• Before advice: Executed before the method invocation.

• After advice: Executed after the method invocation, regardless of its outcome.

• Around advice: Wraps around the method invocation, allowing for custom behavior before and after.

• After-returning advice: Executed after the method successfully returns a value.

• After-throwing advice: Executed after the method throws an exception.

The Java Executor Framework provides a way to manage and control the execution of tasks in a multithreaded environment.

• Allows for easy management of thread pools, reducing overhead of creating new threads for each task.

• Provides a way to schedule tasks for execution at a specific time or with a delay.

• Supports task cancellation and interruption.

• Facilitates handling of task dependencies and coordination between tasks.

• Offers better control over thread execution, such as setting t...read more

Prototype scope in Spring creates a new instance of the bean every time it is requested.

• Prototype scope is used when a new instance of the bean is required for each request.

• It is not thread-safe, as a new instance is created for each request.

• Example: If a bean is defined with prototype scope, a new instance will be created every time it is injected or requested.

The Java Executor Framework provides a way to manage and execute tasks asynchronously in Java applications.

• Create an instance of ExecutorService using Executors class

• Submit tasks for execution using execute() or submit() methods

• Handle the results of the tasks using Future objects

• Shutdown the ExecutorService when tasks are completed using shutdown() method

Inversion of Control is a design principle where the control flow of a program is inverted, with the framework controlling the flow.

• Inversion of Control allows for decoupling of components, making the code more modular and easier to maintain.

• Common examples of Inversion of Control include dependency injection and event listeners.

• Frameworks like Spring and Hibernate make use of Inversion of Control to manage object lifecycles and dependencies.

Java Executor Framework is a framework provided by Java for managing and executing tasks asynchronously.

• It provides a way to manage threads and execute tasks concurrently.

• It includes interfaces like Executor, ExecutorService, and ScheduledExecutorService.

• It allows for better control over thread management and task execution compared to manually managing threads.

• Example: Executors.newFixedThreadPool(5) creates a thread pool with 5 threads for executing tasks.