Spring Framework

 Spring is an open source frame work for building enterprise java applications. Spring contains spring core and collection of projects. Spring Core, often referred to as the core module of the Spring Framework, is the foundational module that provides the essential components and features for building Java applications. Spring Core serves as the foundation for other modules within the Spring ecosystem, such as Spring MVC (Model-View-Controller) for web applications, Spring Data for data access, and more.

The key concepts of spring core are:

  • Inversion of Control (IoC): Spring Core implements the principle of Inversion of Control (IoC), which means that the control of object creation and management is shifted from the application code to the Spring container. This promotes loose coupling and easier maintenance of code.

  • Dependency Injection (DI): Dependency Injection is a core concept in Spring Core. It allows developers to inject dependencies into classes rather than hard-coding them, promoting flexibility and easier testing.

  • Container: The Spring IoC container is at the heart of Spring Core. It manages the lifecycle of Java objects (beans) and applies IoC to enhance the modularity and scalability of applications.

  • Beans: In Spring, a bean is an object that is instantiated, assembled, and otherwise managed by the Spring IoC container. Beans are defined in the Spring configuration and can be Java objects or third-party objects configured and managed by Spring.

  • ApplicationContext: The ApplicationContext is a central and advanced interface in the Spring Framework that is responsible for managing the lifecycle of beans (objects) within a Spring application. It is an advanced form of the IoC container.

  • AOP (Aspect-Oriented Programming): Spring Core supports Aspect-Oriented Programming, allowing developers to modularise cross-cutting concerns like logging, security, and transactions. AOP complements the traditional Object-Oriented Programming (OOP) paradigm.

  • Validation and Data Binding: Spring Core provides support for data validation and binding, allowing developers to validate and bind user input to Java objects.

  • Event Handling: Spring Core supports a robust event handling mechanism, allowing communication between decoupled components within the application.

Here are key components of the Spring ecosystem:

  • Spring Boot:

  • A project that simplifies the process of building, deploying, and running Spring applications. It provides a set of conventions, defaults, and auto-configurations to streamline development.

  • Spring Data:

  • A set of projects that simplify data access in Spring applications. It provides consistent and familiar programming models for various data sources, including relational databases, NoSQL databases, and more.

  • Spring Security:

  • A framework for implementing authentication, authorisation, and protection against common security vulnerabilities in Spring-based applications.

  • Spring Cloud:

  • A set of tools and frameworks for building distributed and cloud-native applications. It includes projects for service discovery, configuration management, load balancing, and more.

  • Spring Integration:

  • A framework for building enterprise integration solutions. It facilitates the exchange of information between different systems and applications.

  • Spring Batch:

  • A framework for building batch processing applications. It simplifies the development of robust and scalable batch processing tasks.

  • Spring Web:

  • Includes various projects related to web development, such as Spring MVC for building web applications, Spring WebFlux for reactive programming, and Spring Web Services for creating web services.

  • Spring Mobile:

  • A project for simplifying the development of mobile web applications.
  • Spring Social:
  • Integrates with popular social media platforms, providing a framework for social login, sharing, and interaction.

  • Spring HATEOAS:

  • Enables the creation of RESTful APIs following the principles of HATEOAS (Hypermedia as the Engine of Application State).

  • Spring Shell:

  • A framework for building command-line applications.

  • Spring Kafka:

  • Integrates the Spring framework with Apache Kafka, providing support for building Kafka-based messaging systems.

  • Spring Data Flow:

  • A cloud-native orchestration service for building data integration and real-time analytics applications.

  • Spring Cloud Data Flow:

  • An extension of Spring Cloud for building and orchestrating data micro-services.

  • Spring Cloud Sleuth:

  • Provides distributed tracing for micro-services architecture.

  • Spring Test:

  • Includes projects and modules for testing Spring applications, such as Spring TestContext Framework and Spring Boot Testing.


In order to set Spring Bean’s scope, we can use @Scope annotation or “scope” attribute in XML configuration files. There are five supported scopes:

  • Singleton
  • Prototype
  • Request
  • Session
  • Global-session

Spring Bean Life Cycle

The life cycle of a Spring bean refers to the various stages it goes through, from instantiation to destruction.

    • Instantiation:

    • The process starts with the creation of a bean instance. This can happen through constructor invocation or through a factory method, depending on the bean configuration.

    • Populating Properties:

    • Once the bean is instantiated, Spring sets its properties and dependencies. This process is known as dependency injection, where the framework injects values into the bean's properties.

    • Bean Post-Processing (Initialization):

    • Spring provides hooks for custom initialization logic through methods annotated with @PostConstruct or implementing the InitializingBean interface. These methods are called after the bean has been instantiated and its dependencies have been injected.

    • Custom Initialization (InitializationCallback):

    • If you prefer programmatic initialization, you can implement the InitializationCallback interface and register it in the bean definition.
    • Bean Ready for Use:
    • At this point, the bean is fully initialized and ready for use. It can be injected into other beans or accessed by other parts of the application.
    • Bean Post-Processing (Destruction):
    • When the application context is shut down or when explicitly triggered, beans can go through a destruction phase. This allows for releasing resources, closing connections, or performing cleanup operations.
      • Custom destruction logic can be added through methods annotated with @PreDestroy or implementing the DisposableBean interface.

    • Custom Destruction (DestructionCallback):

    • If you prefer programmatic destruction, you can implement the DestructionCallback interface and register it in the bean definition.

    • In a nutshell, Spring IoC Container first check for dependency then calls its constructor. After creation of bean, it first injects the dependencies auto wired 0n constructor, Field and setters. Then Aware interfaces(BeanNameAware, BeanClassLoaderAware, ApplicationContextAware…) and annotated method like PostConstruct is invoked. At last init-method is invoked.






    Comments

    Post a Comment

    Popular posts from this blog

    Transform values with a stream

    The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
    Read more

    Collections Framework

     The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
    Read more

    Inspect a collection

    Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
    Read more