riven

Riven

Riven

Configuration in spring

Spring configuration refers to the process of setting up beans and their dependencies in a Spring application context. It allows developers to define how objects are created, how they are wired together, and how they behave in the application.

Types of Configurations

  • XML-based Configurations: Traditional method using XML files to define beans and dependencies.
  • Annotation-based Configurations: Utilizes annotations to simplify configuration and wiring of beans.
  • Java-based Configurations: Employs Java classes with @Configuration annotations to define beans and dependencies.
  • Externalized Configurations: Uses properties files or YAML files to manage configuration values outside of the codebase.

XML-based Configurations

Structure of XML Configurations

In XML-based configurations, the application context is defined in an XML file. Here’s a simple structure:

				
					<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.example.MyBean">
        <property name="dependency" ref="myDependency"/>
    </bean>

    <bean id="myDependency" class="com.example.MyDependency"/>
</beans>

Example

1. Create Bean Classes

				
					// MyBean.java
package com.example;

public class MyBean {
    private MyDependency dependency;

    public void setDependency(MyDependency dependency) {
        this.dependency = dependency;
    }

    public void display() {
        System.out.println("Dependency: " + dependency.getMessage());
    }
}

// MyDependency.java
package com.example;

public class MyDependency {
    public String getMessage() {
        return "Hello from MyDependency!";
    }
}

2. Create XML Configuration File

				
					<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.example.MyBean">
        <property name="dependency" ref="myDependency"/>
    </bean>

    <bean id="myDependency" class="com.example.MyDependency"/>
</beans>

3. Load Application Context and Use Beans

				
					import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBean myBean = (MyBean) context.getBean("myBean");
        myBean.display();  // Output: Dependency: Hello from MyDependency!
    }
}

Advantages of XML Configurations

  • Separation of Concerns: Configurations is kept separate from the application code.
  • Flexibility: Easy to modify bean configurations without changing Java code.

Disadvantages of XML Configurations

  • Verbosity: XML configurations can become lengthy and harder to read.
  • Lack of Type Safety: Errors are caught at runtime rather than compile time.

3. Annotation-based Configuration

Annotation-based configurations allows for a more concise way to define beans using annotations directly in the Java classes.

Common Annotations

  • @Component: Indicates a Spring-managed component.
  • @Autowired: Injects dependencies automatically.
  • @Configuration: Marks a class as a source of bean definitions.
  • @Bean: Indicates that a method produces a bean to be managed by the Spring container.

Example

1. Create Bean Classes with Annotations

				
					import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyBean {
    private final MyDependency dependency;

    @Autowired
    public MyBean(MyDependency dependency) {
        this.dependency = dependency;
    }

    public void display() {
        System.out.println("Dependency: " + dependency.getMessage());
    }
}

@Component
public class MyDependency {
    public String getMessage() {
        return "Hello from MyDependency!";
    }
}

2. Create Java Configuration Class

				
					import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

3. Load Application Context and Use Beans

				
					import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyBean myBean = context.getBean(MyBean.class);
        myBean.display();  // Output: Dependency: Hello from MyDependency!
    }
}

Advantages of Annotation-based Configuration

  • Simplicity: Reduces boilerplate code and improves readability.
  • Type Safety: Errors are caught at compile time.

Disadvantages of Annotation-based Configuration

  • Less Control Over Bean Lifecycle: May not be as explicit as XML configuration in some cases.
  • Coupling: Classes are tightly coupled with Spring annotations.

4. Java-based Configuration

Java-based configuration is similar to annotation-based configuration but focuses more on programmatically defining beans in Java classes.

Example

1. Create Bean Classes

				
					// MyBean.java
package com.example;

public class MyBean {
    private MyDependency dependency;

    public void setDependency(MyDependency dependency) {
        this.dependency = dependency;
    }

    public void display() {
        System.out.println("Dependency: " + dependency.getMessage());
    }
}

// MyDependency.java
package com.example;

public class MyDependency {
    public String getMessage() {
        return "Hello from MyDependency!";
    }
}

2. Create Java Configuration Class

				
					import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean
    public MyBean myBean() {
        MyBean myBean = new MyBean();
        myBean.setDependency(myDependency());
        return myBean;
    }
}

3. Load Application Context and Use Beans

				
					import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyBean myBean = context.getBean(MyBean.class);
        myBean.display();  // Output: Dependency: Hello from MyDependency!
    }
}

Advantages of Java-based Configuration

  • Type Safety: Errors are caught at compile time.
  • Flexibility: Programmatic control over bean instantiation.

Disadvantages of Java-based Configuration

  • More Code: Can lead to more boilerplate code compared to annotations.
  • Less Separation: Configuration is mixed with Java logic.

5. Externalized Configuration

Externalized configuration allows you to manage properties outside the code, making it easier to manage different environments (e.g., development, testing, production).

Using Properties Files

1. Create a Properties File

				
					# application.properties
dependency.message=Hello from Externalized Configuration!

2. Modify Bean Class to Use Properties

				
					import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyDependency {
    @Value("${dependency.message}")
    private String message;

    public String getMessage() {
        return message;
    }
}

3. Create Java Configuration Class to Load Properties

				
					import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;

@Configuration
public class AppConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer properties() {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        configurer.setLocation(new ClassPathResource("application.properties"));
        return configurer;
    }

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean
    public MyBean myBean() {
        MyBean myBean = new MyBean();
        myBean.setDependency(myDependency());
        return myBean;
    }
}

4. Load Application Context and Use Beans

				
					import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyBean myBean = context.getBean(MyBean.class);
        myBean.display();  // Output: Dependency: Hello from Externalized Configuration!
    }
}

Advantages of Externalized Configuration

  • Environment Independence: Easily change configurations based on the environment.
  • Flexibility: Update configurations without changing the code.

Disadvantages of Externalized Configuration

  • Complexity: Managing multiple configuration files can become complex.
  • Overhead: Loading properties files can add overhead to application startup

Related topic

Lambda expression in java 8
lambda expression in java 8 Lambda expressions were introduced in Java 8 to provide a clear and concise...
Return Statement in java with example
Return statement in java with example The return statement in Java is a fundamental aspect of the language...
Result set in java
Resultset in java with example In Java Database Connectivity (JDBC), the ResultSet interface represents...
Java instanceof
Java instanceof In Java instanceof operator is a fundamental part of the language that allows you to...
File handling in java
File handling in java with example File handling in Java refers to the process of reading from and writing...
Comparator in java with example
comparator in java with example In Java, sorting collections of objects is a common task that often requires...
IOC container in spring
What is  IoC Container in spring? The Spring IoC container is responsible for managing the complete...
Switch statement in java
Java switch statement The switch statement in Java is a powerful control flow structure that allows you...
Hashmap in java with example
what is hashmap in java with example In Java, a HashMap is part of the Java Collections Framework and...
What is a Next-Generation Firewall?
What is a Next-Generation Firewall? A Next-Generation Firewall is an advanced network security device...