উদাহরণ সহ Bean Configuration

স্প্রিং ফ্রেমওয়ার্কে Bean Configuration হল একটি প্রক্রিয়া যার মাধ্যমে স্প্রিং কনটেইনারকে বলে দেওয়া হয় কিভাবে এবং কখন একটি অবজেক্ট (bean) তৈরি হবে এবং এর ডিপেনডেন্সিগুলি কিভাবে ইনজেক্ট করা হবে। স্প্রিং ফ্রেমওয়ার্কে ডিপেনডেন্সি ইনজেকশন (Dependency Injection - DI) এর মাধ্যমে আপনি একাধিক কনফিগারেশন পদ্ধতি ব্যবহার করে বীন কনফিগার করতে পারেন, যেমন XML কনফিগারেশন, অ্যানোটেশন কনফিগারেশন এবং Java-based কনফিগারেশন।

এখানে, আমরা Bean Configuration এর তিনটি সাধারণ পদ্ধতির (XML, Annotations, এবং Java-based Configuration) উদাহরণসহ আলোচনা করব।

1. XML Configuration এর মাধ্যমে Bean Configuration

স্প্রিং ফ্রেমওয়ার্কে XML-based configuration প্রাথমিকভাবে ব্যবহৃত হত, এবং এখনো কিছু অ্যাপ্লিকেশনে ব্যবহৃত হয়। এখানে একটি bean কনফিগার করতে XML ফাইলের মধ্যে কনফিগারেশন করতে হয়।

Step 1: Spring XML Configuration

beans.xml ফাইল তৈরি করুন:

<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd">

    <!-- Define a bean for UserService -->
    <bean id="userService" class="com.example.UserService">
        <!-- Inject dependencies -->
    </bean>

    <!-- Define a bean for UserController -->
    <bean id="userController" class="com.example.UserController">
        <constructor-arg ref="userService"/>
    </bean>

</beans>

ব্যাখ্যা:

• এখানে, userService এবং userController নামের দুটি bean কনফিগার করা হয়েছে।
• userController এর জন্য userService ডিপেনডেন্সি ইনজেক্ট করা হয়েছে constructor-arg দ্বারা।

Step 2: Service and Controller Class

package com.example;

public class UserService {
    public void createUser(String name) {
        System.out.println("User " + name + " created.");
    }
}

package com.example;

public class UserController {
    
    private UserService userService;

    // Constructor-based DI
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void processUser(String name) {
        userService.createUser(name);
    }
}

Step 3: Main Application

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

public class Application {
    public static void main(String[] args) {
        // Load Spring context from XML file
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        
        // Retrieve bean from the context
        UserController userController = (UserController) context.getBean("userController");
        userController.processUser("John Doe");
    }
}

Output:

User John Doe created.

এখানে, userController বীনটি কনফিগার করা হয়েছে, এবং userService বীনটি কনস্ট্রাক্টর দিয়ে ইনজেক্ট করা হয়েছে।

2. Annotation-based Configuration (Autowiring)

স্প্রিং 2.5 থেকে Annotations-based configuration ব্যবহার করা শুরু হয়, যা খুবই জনপ্রিয় এবং সহজ। এর মাধ্যমে @Component, @Autowired, এবং @Configuration অ্যানোটেশন ব্যবহার করে স্প্রিং কনটেইনারে বীন কনফিগার করা যায়।

Step 1: Service and Controller Class with Annotations

package com.example;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void createUser(String name) {
        System.out.println("User " + name + " created.");
    }
}

package com.example;

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

@Controller
public class UserController {
    
    private final UserService userService;

    // Autowire the UserService dependency
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void processUser(String name) {
        userService.createUser(name);
    }
}

Step 2: Java-based Configuration with Annotations

package com.example;

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

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

    @Bean
    public UserController userController() {
        return new UserController(userService());
    }

    @Bean
    public UserService userService() {
        return new UserService();
    }
}

Step 3: Main Application

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

public class Application {
    public static void main(String[] args) {
        // Load Spring context from Java-based config class
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Retrieve bean from the context
        UserController userController = context.getBean(UserController.class);
        userController.processUser("John Doe");
    }
}

Output:

User John Doe created.

এখানে, আমরা @Service, @Controller, এবং @Autowired অ্যানোটেশন ব্যবহার করেছি, যা স্প্রিং কনটেইনারে বীন সৃষ্টির জন্য এবং ডিপেনডেন্সি ইনজেকশনের জন্য ব্যবহৃত হয়েছে।

3. Java-based Configuration (Without Annotations)

এখন, Java-based Configuration এর মাধ্যমে আমরা স্প্রিং বীন কনফিগারেশন করতে পারি। এটি স্প্রিং 3.0+ থেকে শুরু হওয়া একটি কৌশল, যা @Configuration অ্যানোটেশন ব্যবহার করে স্প্রিং কনফিগারেশন ক্লাস তৈরি করা হয়।

Step 1: Service and Controller Class

package com.example;

public class UserService {
    public void createUser(String name) {
        System.out.println("User " + name + " created.");
    }
}

package com.example;

public class UserController {
    
    private UserService userService;

    // Setter-based DI
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void processUser(String name) {
        userService.createUser(name);
    }
}

Step 2: Java-based Configuration Class

package com.example;

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

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }

    @Bean
    public UserController userController() {
        UserController userController = new UserController();
        userController.setUserService(userService());
        return userController;
    }
}

Step 3: Main Application

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

public class Application {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Retrieve bean from the context
        UserController userController = context.getBean(UserController.class);
        userController.processUser("John Doe");
    }
}

Output:

User John Doe created.

এখানে, Java-based configuration ব্যবহার করে স্প্রিং বীন কনফিগার করা হয়েছে।

Conclusion

স্প্রিং ফ্রেমওয়ার্কে Bean Configuration এর তিনটি সাধারণ পদ্ধতি হলো:

1. XML Configuration: XML ফাইল ব্যবহার করে বীন কনফিগার করা।
2. Annotation-based Configuration: অ্যানোটেশন ব্যবহার করে বীন কনফিগার করা (যেমন @Component, @Service, @Autowired)।
3. Java-based Configuration: @Configuration এবং @Bean অ্যানোটেশন ব্যবহার করে Java কোডে কনফিগারেশন করা।

এই তিনটি পদ্ধতির মাধ্যমে আপনি স্প্রিং কনটেইনারে বীন কনফিগার এবং ডিপেনডেন্সি ইনজেকশন পরিচালনা করতে পারেন। Annotation-based এবং Java-based কনফিগারেশন বর্তমানে সবচেয়ে বেশি ব্যবহৃত হয়, কারণ এগুলো কোডের মধ্যে কমপ্যাক্ট এবং সহজে রক্ষণাবেক্ষণযোগ্য।