Java Technologies Guice এবং Lifecycle Management গাইড ও নোট

Guice একটি শক্তিশালী Dependency Injection (DI) ফ্রেমওয়ার্ক যা ডিপেনডেন্সি ইনজেকশন এবং Object Lifecycle Management (অবজেক্টের জীবনকাল ব্যবস্থাপনা) এর জন্য অত্যন্ত কার্যকরী। Guice ডিপেনডেন্সি ইনজেকশনের মাধ্যমে অবজেক্টের জীবনকাল এবং তার ব্যবহারের সময়কে নিয়ন্ত্রণ করতে সহায়তা করে।

Guice এর মাধ্যমে Lifecycle Management মূলত Scopes এবং Lifecycle Methods ব্যবহার করে হয়, যা অবজেক্ট তৈরির সময়কাল, ব্যবহারের সময়কাল এবং ধ্বংসের সময়কাল নির্ধারণ করতে সহায়তা করে।

Guice এর Lifecycle Management এর মূল উপাদানগুলি

1. Scopes:
   • Scopes হল Guice এর জীবনের সময়কাল নিয়ন্ত্রণের প্রধান উপায়। Guice-এ বিভিন্ন ধরনের স্কোপ থাকে, যার মাধ্যমে আপনি নির্ধারণ করতে পারেন যে একটি ক্লাসের ইনস্ট্যান্স কতবার তৈরি হবে এবং তার জীবনকাল কিভাবে পরিচালিত হবে।
2. Lifecycle Methods (Start, Stop):
   • Guice কিছু Lifecycle Methods সাপোর্ট করে, যেখানে আপনি অবজেক্টের জীবনকাল চলাকালে নির্দিষ্ট কাজগুলো করতে পারেন, যেমন initialization বা cleanup।

1. Scopes এবং Object Lifecycle

Singleton Scope

• Singleton Scope-এ, Guice নিশ্চিত করে যে একটি ক্লাসের কেবলমাত্র একটি ইনস্ট্যান্স তৈরি হবে এবং এটি অ্যাপ্লিকেশনের পুরো জীবনকাল জুড়ে পুনরায় ব্যবহার হবে।
• Singleton স্কোপের মাধ্যমে অবজেক্টের lifetime অ্যাপ্লিকেশন লেভেলে একবার তৈরি হবে এবং তারপর বারবার একই অবজেক্ট ব্যবহার করা হবে।

উদাহরণ:

import com.google.inject.AbstractModule;
import com.google.inject.Singleton;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        // Singleton scope for MyService
        bind(MyService.class).in(Singleton.class);
    }
}

public class MyService {
    public void execute() {
        System.out.println("Service executed");
    }
}

Main Class (Application)

import com.google.inject.Guice;
import com.google.inject.Injector;

public class Application {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        MyService service1 = injector.getInstance(MyService.class);
        MyService service2 = injector.getInstance(MyService.class);

        // Both service1 and service2 will refer to the same instance
        service1.execute();
        System.out.println(service1 == service2);  // Output: true
    }
}

Explanation:

• MyService ক্লাসটি Singleton স্কোপে বাইনড করা হয়েছে। এর মানে হল যে, service1 এবং service2 একই ইনস্ট্যান্সটি পাবে।

Prototype Scope

• Prototype Scope-এ, প্রতিবার একটি ক্লাসের ইনস্ট্যান্স রিকোয়েস্ট করার পর একটি নতুন ইনস্ট্যান্স তৈরি হয়। এটি সেইসব ক্ষেত্রে উপকারী যেখানে আপনার একটি নতুন অবজেক্ট প্রতি রিকোয়েস্টে প্রয়োজন হয়।

উদাহরণ:

import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        // Default prototype scope (new instance every time)
        bind(MyService.class).to(MyService.class);
    }
}

public class MyService {
    public void execute() {
        System.out.println("Service executed");
    }
}

Main Class (Application)

import com.google.inject.Guice;
import com.google.inject.Injector;

public class Application {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        MyService service1 = injector.getInstance(MyService.class);
        MyService service2 = injector.getInstance(MyService.class);

        // Each service will be a different instance
        service1.execute();
        service2.execute();
        System.out.println(service1 == service2);  // Output: false
    }
}

Explanation:

• Prototype স্কোপে, service1 এবং service2 দুটি আলাদা ইনস্ট্যান্স হবে, কারণ প্রতিবার রিকোয়েস্টে নতুন অবজেক্ট তৈরি হবে।

Custom Scopes

• Guice আপনাকে custom scopes তৈরি করার সুযোগ দেয়। আপনি নিজের কাস্টম স্কোপ তৈরি করতে পারেন যা নির্দিষ্ট ডিপেনডেন্সি লাইফসাইকেল পরিচালনা করতে সহায়তা করবে।

উদাহরণ:

import com.google.inject.Scope;
import com.google.inject.spi.Provider;
import com.google.inject.Inject;
import com.google.inject.Key;
import java.util.HashMap;
import java.util.Map;

public class RequestScope implements Scope {
    private Map<Key<?>, Object> currentScope = new HashMap<>();

    @Override
    public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped) {
        return () -> {
            if (!currentScope.containsKey(key)) {
                currentScope.put(key, unscoped.get());
            }
            return (T) currentScope.get(key);
        };
    }
}

এখানে, RequestScope একটি কাস্টম স্কোপ যা বিভিন্ন ডিপেনডেন্সি গুলি request-based লাইফসাইকেল পরিচালনা করে। এই স্কোপে, একই রিকোয়েস্টের মধ্যে ডিপেনডেন্সি গুলি একবার তৈরি হয় এবং পরবর্তী রিকোয়েস্টের জন্য একটি নতুন ইনস্ট্যান্স তৈরি করা হয়।

2. Lifecycle Methods (Start, Stop, etc.)

Guice কিছু Lifecycle Methods সাপোর্ট করে, যেমন start(), stop(), বা initialize() যা অবজেক্টের জীবনকাল চলাকালে কোনো নির্দিষ্ট কাজ বা ইন্টিগ্রেশন শুরু বা শেষ করার জন্য ব্যবহার করা যায়। Guice এই ফিচারটি Managed Objects (যেমন, @PostConstruct, @PreDestroy) বা Lifecycle Listeners এর মাধ্যমে সরবরাহ করে।

Lifecycle Methods উদাহরণ:

import com.google.inject.Inject;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyService {
    @Inject
    public MyService() {
        // Constructor logic
    }

    @PostConstruct
    public void start() {
        System.out.println("Service started");
    }

    @PreDestroy
    public void stop() {
        System.out.println("Service stopped");
    }
}

এখানে @PostConstruct এবং @PreDestroy অ্যানোটেশন ব্যবহার করা হয়েছে, যা অবজেক্টের জীবনচক্রে initialization এবং cleanup এর কাজ সম্পাদন করতে সহায়তা করে।

3. Guice এর Lifecycle Management এর প্রয়োগ

Guice এর মাধ্যমে Object Lifecycle Management নিশ্চিত করা হয় নিম্নলিখিত উপায়ে:

• Scopes (Singleton, Prototype, Custom) ব্যবহার করে বিভিন্ন অবজেক্টের জীবনকাল কনফিগার করা।
• Lifecycle Methods যেমন @PostConstruct, @PreDestroy ব্যবহার করে অবজেক্টের ইনিশিয়ালাইজেশন এবং ক্লিনআপ কনফিগার করা।
• Custom Scope তৈরি করে আপনি আরো বিস্তারিত এবং কাস্টম লাইফসাইকেল পরিচালনা করতে পারেন।

Guice এর Object Lifecycle Management নিশ্চিত করে যে ডিপেনডেন্সি ইনজেকশন প্রক্রিয়া সহজ, স্থিতিশীল এবং সুবিধাজনক হয়। Scopes ব্যবহার করে Guice আপনাকে অবজেক্টের জীবনকাল কাস্টমাইজ করতে দেয়, যেমন Singleton, Prototype, এবং Custom Scopes। এছাড়া Lifecycle Methods (যেমন @PostConstruct, @PreDestroy) ব্যবহার করে অবজেক্টের ইনিশিয়ালাইজেশন এবং ক্লিনআপ পরিচালনা করা যায়, যা অ্যাপ্লিকেশনের স্থিতিশীলতা এবং কার্যক্ষমতা নিশ্চিত করে। Guice এর এই ফিচারগুলি একটি মডুলার এবং স্কেলেবল অ্যাপ্লিকেশন নির্মাণে গুরুত্বপূর্ণ ভূমিকা পালন করে।

Guice একটি dependency injection (DI) ফ্রেমওয়ার্ক যা Java অ্যাপ্লিকেশনগুলিতে ডিপেন্ডেন্সি ইনজেকশন পরিচালনা করে। Guice-এর মূল লক্ষ্য হল loose coupling তৈরি করা, যাতে বিভিন্ন ক্লাসের মধ্যে ডিপেন্ডেন্সি সরবরাহ এবং পরিচালনা সহজ হয়। তবে, এর একটি গুরুত্বপূর্ণ ভূমিকা Object Lifecycle Management বা অবজেক্টের জীবনচক্র পরিচালনা করা। Object Lifecycle Management হল সেই প্রক্রিয়া যার মাধ্যমে একটি অবজেক্টের জীবনচক্র নির্ধারণ করা হয়—অর্থাৎ, এটি কখন তৈরি হবে, কখন ধ্বংস হবে এবং কখন তার অবস্থা পরিবর্তিত হবে।

Object Lifecycle Management এর ভূমিকা

Java অ্যাপ্লিকেশনে অবজেক্টগুলো কীভাবে তৈরি, ব্যবহৃত এবং ধ্বংস হবে তা সঠিকভাবে পরিচালনা করা খুবই গুরুত্বপূর্ণ। Guice এই প্রক্রিয়া সহজ করে তোলে। এখানে Object Lifecycle Management এর কিছু মূল ভূমিকা তুলে ধরা হল:

1. Singleton Instances Management:
   • Guice সিঙ্গলটন অবজেক্টগুলোর জীবনচক্র পরিচালনা করতে সাহায্য করে। এতে, একটি নির্দিষ্ট ক্লাসের একটি মাত্র ইনস্ট্যান্স তৈরি হয় এবং সেটি পুরো অ্যাপ্লিকেশনজুড়ে ব্যবহৃত হয়।
2. Scoped Lifecycle:
   • Guice বিভিন্ন scopes (যেমন: singleton, session-scoped, request-scoped) ব্যবহারের মাধ্যমে অবজেক্টের জীবনচক্র নির্ধারণ করতে সাহায্য করে। প্রতিটি scope একটি অবজেক্টের তৈরি হওয়া এবং ধ্বংস হওয়া নিয়ন্ত্রণ করে।
3. Automatic Cleanup:
   • যখন কোনও অবজেক্ট আর প্রয়োজনীয় থাকে না, Guice স্বয়ংক্রিয়ভাবে তার cleanup পরিচালনা করতে পারে। এটি অ্যাপ্লিকেশনের memory management উন্নত করে এবং resource leaks প্রতিরোধ করে।
4. Dependency Management:
   • Guice ডিপেন্ডেন্সি ইনজেকশনের মাধ্যমে অবজেক্টের সম্পর্ক ও জীবনচক্রের পাশাপাশি ডিপেন্ডেন্সি গুলি পরিষ্কারভাবে পরিচালনা করে। ডিপেন্ডেন্সি গুলি ঠিক সময়ে তৈরি এবং ধ্বংস হয়, যাতে অ্যাপ্লিকেশন ঠিকমতো কাজ করে।

Guice এর Object Lifecycle Management এর মূল দিকগুলো

1. Singleton Scope

Guice-এর Singleton স্কোপের মাধ্যমে একটি অবজেক্ট কেবলমাত্র একবার তৈরি হয় এবং অ্যাপ্লিকেশন চলাকালীন সময়ে এটি পুনরায় ব্যবহার করা হয়। এটি কার্যকরী কারণ আপনি একটি অবজেক্টের একাধিক ইনস্ট্যান্স তৈরি করতে চান না, যেমন কনফিগারেশন বা ক্যাশিং অবজেক্টের ক্ষেত্রে।

উদাহরণ (Singleton Scope)

import com.google.inject.*;

class Database {
    // একটি Singleton অবজেক্টের মতো ব্যবহার হবে
    public void connect() {
        System.out.println("Connected to Database!");
    }
}

public class SingletonExample {
    public static void main(String[] args) {
        // Guice Injector তৈরি
        Injector injector = Guice.createInjector();

        // Database ক্লাসের ইনস্ট্যান্স তৈরি এবং reuse
        Database database1 = injector.getInstance(Database.class);
        Database database2 = injector.getInstance(Database.class);

        // চেক করা হচ্ছে যে দুটি database ইনস্ট্যান্স একই কিনা
        System.out.println(database1 == database2);  // Output: true
    }
}

এখানে, Singleton Scope নিশ্চিত করে যে Database ক্লাসের একটি মাত্র ইনস্ট্যান্স তৈরি হবে এবং সেটি পুনরায় ব্যবহৃত হবে।

2. Request/Session Scoped Lifecycle

Guice আরও স্কোপ প্রদান করে, যেমন request-scoped এবং session-scoped অবজেক্ট। এই স্কোপগুলি ব্যবহার করে আপনি একটি অবজেক্টের জীবনচক্র শুধুমাত্র একটি নির্দিষ্ট সেশনে বা রিকোয়েস্টের মধ্যে সীমাবদ্ধ রাখতে পারেন।

উদাহরণ (Request Scoped)

import com.google.inject.*;
import com.google.inject.servlet.RequestScoped;

@RequestScoped
class RequestService {
    public void performTask() {
        System.out.println("Performing task in request scope!");
    }
}

public class RequestScopedExample {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();

        // RequestService ইনস্ট্যান্স তৈরি
        RequestService service1 = injector.getInstance(RequestService.class);
        RequestService service2 = injector.getInstance(RequestService.class);

        // চেক করা হচ্ছে যে দুটি ইনস্ট্যান্স আলাদা কি না
        System.out.println(service1 == service2);  // Output: false (RequestScoped)
    }
}

এখানে, RequestScope নিশ্চিত করে যে RequestService ক্লাসের প্রতিটি রিকোয়েস্টের জন্য আলাদা ইনস্ট্যান্স তৈরি হবে।

3. Assisted Injection এবং Object Lifecycle

Assisted Injection ব্যবহার করে, আপনি কিছু প্যারামিটার runtime এ ইনজেক্ট করতে পারেন। এটি সাধারণত ব্যবহার হয় যখন Guice প্যারামিটারগুলো সরাসরি ইনজেক্ট করতে সক্ষম না, যেমন কিছু কাস্টম বা runtime প্যারামিটার যা সরাসরি Guice দ্বারা ডিপেন্ডেন্সি হিসেবে ইনজেক্ট করা সম্ভব নয়।

import com.google.inject.*;
import com.google.inject.assistedinject.*;

interface ServiceFactory {
    Service createService(String name);
}

class Service {
    private final String name;

    // Assisted Injection constructor
    @AssistedInject
    public Service(@Assisted String name) {
        this.name = name;
    }

    public void display() {
        System.out.println("Service Name: " + name);
    }
}

public class AssistedInjectionExample {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AbstractModule() {
            @Override
            protected void configure() {
                bind(ServiceFactory.class).toFactory();
            }
        });

        ServiceFactory factory = injector.getInstance(ServiceFactory.class);
        Service service = factory.createService("Test Service");
        service.display();  // Output: Service Name: Test Service
    }
}

এখানে Assisted Injection Guice এর lifecycle management এবং runtime প্যারামিটার ইনজেকশনের মাধ্যমে অবজেক্ট তৈরি ও পরিচালনা করার সুযোগ দেয়।

Guice-এ Object Lifecycle Management এর উপকারিতা

Guice এর Object Lifecycle Management একটি শক্তিশালী ফিচার যা অবজেক্ট তৈরির সময় থেকে ধ্বংস হওয়া পর্যন্ত dependency lifecycle সঠিকভাবে পরিচালনা করে। এটি সিঙ্গলটন অবজেক্ট, স্কোপড অবজেক্ট এবং Assisted Injection এর মাধ্যমে কাস্টম ইনজেকশন প্যাটার্নের সুবিধা প্রদান করে। Guice এই ব্যবস্থাপনা প্রক্রিয়ার মাধ্যমে অ্যাপ্লিকেশনের মেমরি ব্যবস্থাপনা, পারফরম্যান্স এবং টেস্টেবিলিটি উন্নত করে, যা ডেভেলপারদের অ্যাপ্লিকেশন তৈরি করার কাজকে আরও সহজ এবং কার্যকর করে তোলে।

Guice একটি শক্তিশালী Dependency Injection (DI) ফ্রেমওয়ার্ক যা Java অ্যাপ্লিকেশনে ডিপেনডেন্সি ইনজেকশন ব্যবস্থাপনা সরবরাহ করে। Object Lifecycle কনফিগার করা হচ্ছে Guice এর গুরুত্বপূর্ণ বৈশিষ্ট্যগুলির মধ্যে একটি, যেখানে আপনি একটি নির্দিষ্ট অবজেক্টের জীবনকাল নির্ধারণ করতে পারেন, যেমন কখন তা তৈরি হবে, কখন ধ্বংস হবে, এবং কতবার ব্যবহার হবে। Guice বিভিন্ন ধরনের Scopes সাপোর্ট করে, যার মাধ্যমে আপনি ডিপেনডেন্সির জীবনকাল কাস্টমাইজ করতে পারবেন।

Guice এ Object Lifecycle কনফিগার করতে Scopes ব্যবহার করা হয়, এবং প্রতিটি স্কোপের জন্য অবজেক্টের জীবনকাল এবং ব্যবহারের পরিমাণ নির্ধারণ করা হয়।

Guice-এ Object Lifecycle এর প্রধান Concepts

1. Singleton Scope:
   • Singleton স্কোপে, একটি ক্লাসের শুধুমাত্র একটি ইনস্ট্যান্স তৈরি করা হয় এবং এটি অ্যাপ্লিকেশনের পুরো জীবনকালে পুনরায় ব্যবহার করা হয়।
2. Prototype Scope:
   • Prototype স্কোপে, প্রতি ডিপেনডেন্সি রিকোয়েস্টের জন্য একটি নতুন ইনস্ট্যান্স তৈরি করা হয়। এর মানে হল যে, আপনি যতবার একটি নির্দিষ্ট ক্লাসের ইনস্ট্যান্স রিকুয়েস্ট করবেন, ততবার একটি নতুন অবজেক্ট তৈরি হবে।
3. Custom Scopes:
   • Guice আপনাকে custom scopes তৈরি করার অনুমতি দেয়, যেখানে আপনি নিজের প্রয়োজন অনুসারে স্কোপ কনফিগার করতে পারেন। উদাহরণস্বরূপ, আপনি একটি session scope বা request scope তৈরি করতে পারেন যা ওয়েব অ্যাপ্লিকেশনে ব্যবহার উপযোগী হতে পারে।

1. Singleton Scope এর উদাহরণ

Singleton Scope Guice এ খুবই সাধারণ এবং ব্যবহৃত স্কোপ, যেখানে একই ক্লাসের একটি ইনস্ট্যান্স কেবল একবার তৈরি হয় এবং এটি অ্যাপ্লিকেশনের বাকি অংশে পুনরায় ব্যবহার করা হয়।

কোড উদাহরণ:

import com.google.inject.AbstractModule;
import com.google.inject.Singleton;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        // Singleton scope for MyService
        bind(MyService.class).in(Singleton.class);
    }
}

public class MyService {
    public void execute() {
        System.out.println("Service executed");
    }
}

Main Class (Application)

import com.google.inject.Guice;
import com.google.inject.Injector;

public class Application {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        MyService service1 = injector.getInstance(MyService.class);
        MyService service2 = injector.getInstance(MyService.class);

        // Both service1 and service2 will refer to the same instance
        service1.execute();
        System.out.println(service1 == service2);  // Output: true
    }
}

এখানে, MyService ক্লাসটি Singleton স্কোপে বাইনড করা হয়েছে। এর মানে হলো, Guice কেবল একটি MyService ইনস্ট্যান্স তৈরি করবে এবং দুইটি আলাদা রিকোয়েস্টে একই ইনস্ট্যান্সটি প্রদান করবে।

2. Prototype Scope এর উদাহরণ

Prototype Scope ব্যবহারের ক্ষেত্রে, আপনি যতবার একটি ক্লাসের ইনস্ট্যান্স রিকোয়েস্ট করবেন, ততবার Guice নতুন একটি অবজেক্ট তৈরি করবে।

কোড উদাহরণ:

import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        // Prototype scope for MyService
        bind(MyService.class).to(MyService.class);  // By default, this is prototype scope
    }
}

public class MyService {
    public void execute() {
        System.out.println("Service executed");
    }
}

Main Class (Application)

import com.google.inject.Guice;
import com.google.inject.Injector;

public class Application {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        MyService service1 = injector.getInstance(MyService.class);
        MyService service2 = injector.getInstance(MyService.class);

        // Each service will be a different instance
        service1.execute();
        service2.execute();
        System.out.println(service1 == service2);  // Output: false
    }
}

এখানে, Prototype স্কোপ ব্যবহৃত হয়েছে, যা নিশ্চিত করে যে service1 এবং service2 দুটি আলাদা ইনস্ট্যান্স হবে।

3. Custom Scopes (Request, Session, etc.)

Guice আপনাকে custom scopes তৈরি করার অনুমতি দেয়, যার মাধ্যমে আপনি request scope, session scope, অথবা আপনার নিজস্ব স্কোপ তৈরি করতে পারেন।

Custom Scope তৈরি করা

import com.google.inject.Scope;
import com.google.inject.spi.Provider;
import com.google.inject.Inject;

public class RequestScope implements Scope {
    // Custom scope implementation logic
    @Override
    public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped) {
        return () -> {
            // Return a new instance for each request
            return unscoped.get();
        };
    }
}

Module এ Custom Scope ব্যবহার করা

import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(MyService.class).in(RequestScope.class);
    }
}

এখানে, RequestScope হল একটি কাস্টম স্কোপ, যেখানে ইনস্ট্যান্সগুলি প্রতি রিকোয়েস্টে নতুনভাবে তৈরি হয়। এটি সাধারণত ওয়েব অ্যাপ্লিকেশনে ব্যবহার করা হয়, যেখানে প্রতি HTTP রিকোয়েস্টে একটি নতুন অবজেক্ট প্রয়োজন হয়।

4. Lifecycle Methods (Start, Stop, etc.)

Guice কিছু Lifecycle Methods সাপোর্ট করে যা আপনাকে অবজেক্টের জীবনকাল এবং ব্যবহার পরবর্তী কার্যকলাপ পরিচালনা করতে সহায়তা করে। উদাহরণস্বরূপ, কিছু অবজেক্ট স্টার্ট এবং স্টপ সময়সীমায় নির্দিষ্ট কার্যকলাপ পরিচালনা করতে পারে।

Lifecycle Methods ব্যবহার:

import com.google.inject.Inject;

public class MyService {
    @Inject
    public MyService() {
        // Initialization logic
    }

    public void start() {
        System.out.println("Service started");
    }

    public void stop() {
        System.out.println("Service stopped");
    }
}

এখানে start() এবং stop() মেথড গুলি লifecycle পরিচালনা করতে ব্যবহৃত হয়, যাতে অবজেক্টটি প্রপারলি ইন্সট্যানশিয়েট এবং ডিস্ট্রয় হতে পারে।

Guice-এ Object Lifecycle কনফিগার করা অত্যন্ত গুরুত্বপূর্ণ একটি বিষয়, যা DI ব্যবস্থাপনাকে আরও শক্তিশালী ও কার্যকর করে তোলে। Guice বিভিন্ন scopes সরবরাহ করে, যেমন Singleton, Prototype, এবং Custom Scopes, যা আপনাকে অবজেক্টের জীবনকাল নিয়ন্ত্রণ করতে সহায়তা করে। এগুলি অ্যাপ্লিকেশন স্থিতিশীলতা, পারফরম্যান্স এবং মেমরি ব্যবস্থাপনাকে উন্নত করতে সাহায্য করে। Guice এর Object Lifecycle কনফিগারেশন অত্যন্ত ফ্লেক্সিবল, এবং বিভিন্ন প্রয়োজনে এটি কার্যকরী হয়ে থাকে।

• @PostConstruct এবং @PreDestroy অ্যানোটেশনগুলি Java EE (Enterprise Edition) এবং Guice-এ ক্লাসের অবজেক্ট তৈরি এবং ধ্বংসের সময় নির্দিষ্ট মেথডগুলোকে কার্যকরী (invoke) করার জন্য ব্যবহৃত হয়। এই অ্যানোটেশনগুলি সাধারণত কোডের শুরুতে এবং শেষের সময় জীবনের (lifecycle) নির্দিষ্ট আচরণ নির্ধারণ করতে ব্যবহৃত হয়।
• @PostConstruct: যখন কোনো অবজেক্ট তৈরি হয়, তার পরে এই অ্যানোটেশনযুক্ত মেথডটি স্বয়ংক্রিয়ভাবে কল করা হয়। এটি সাধারণত অবজেক্টের initialization এবং সেটআপ করার জন্য ব্যবহৃত হয়।
• @PreDestroy: যখন অবজেক্টটি ধ্বংস হয়, তখন এই অ্যানোটেশনযুক্ত মেথডটি স্বয়ংক্রিয়ভাবে কল করা হয়। এটি অবজেক্টের cleanup বা বন্ধ করার জন্য ব্যবহৃত হয়।
• Guice এর @PostConstruct এবং @PreDestroy অ্যানোটেশনগুলো JSR-250 (Java Specification Request) এর অংশ, যা Guice-এ স্বয়ংক্রিয়ভাবে নির্দিষ্ট কাজগুলিকে সম্পন্ন করতে ব্যবহৃত হয়।

• ---

• Guice: @PostConstruct এবং @PreDestroy এর ব্যবহার

• Step 1: Maven Dependency (Optional)

• Guice সাধারণত @PostConstruct এবং @PreDestroy অ্যানোটেশনগুলিকে সাপোর্ট করে, তবে আপনি যদি Java EE স্পেসিফিকেশন অনুযায়ী কাজ করতে চান, তবে javax.annotation প্যাকেজটি আপনার প্রজেক্টে থাকতে হবে। আপনি এটি Maven অথবা Gradle এর মাধ্যমে অ্যাড করতে পারেন:
• Maven Dependency:

• <dependency>
      <groupId>javax.annotation</groupId>
      <artifactId>javax.annotation-api</artifactId>
      <version>1.3.2</version>
  </dependency>
  

• Step 2: @PostConstruct এবং @PreDestroy ব্যবহার

• ধরা যাক, আমাদের একটি DatabaseService ক্লাস রয়েছে, যা অবজেক্ট ইনিশিয়ালাইজ করার সময় ডাটাবেজ কনফিগারেশন লোড করবে এবং অবজেক্ট ধ্বংসের সময় কনেকশন বন্ধ করবে।

• import javax.annotation.PostConstruct;
  import javax.annotation.PreDestroy;
  
  public class DatabaseService {
      private String databaseUrl;
  
      public DatabaseService(String databaseUrl) {
          this.databaseUrl = databaseUrl;
      }
  
      @PostConstruct
      public void init() {
          // PostConstruct: Database কনফিগারেশন লোড করা হচ্ছে
          System.out.println("Initializing Database connection to: " + databaseUrl);
          // Initialize database connection or other resources
      }
  
      @PreDestroy
      public void cleanup() {
          // PreDestroy: Cleanup বা কনফিগারেশন বন্ধ করা হচ্ছে
          System.out.println("Cleaning up and closing database connection.");
          // Cleanup resources or close database connection
      }
  
      public void query() {
          System.out.println("Executing query on: " + databaseUrl);
      }
  }
  

• এখানে, @PostConstruct মেথড init()টি DatabaseService ক্লাসের অবজেক্ট তৈরি হওয়ার পর কল হবে এবং @PreDestroy মেথড cleanup() ক্লাসের অবজেক্ট ধ্বংস হওয়ার আগে কল হবে।

• Step 3: Guice Module এ @PostConstruct এবং @PreDestroy অ্যানোটেশন ব্যবহার

• Guice এ @PostConstruct এবং @PreDestroy অ্যানোটেশন সাপোর্ট করার জন্য আমরা LifecycleModule বা @Inject মেথড ব্যবহারের মাধ্যমে এটি কনফিগার করতে পারি।

• import com.google.inject.AbstractModule;
  import com.google.inject.Provides;
  import com.google.inject.Singleton;
  
  public class AppModule extends AbstractModule {
      @Override
      protected void configure() {
          // Guice কে বলে DatabaseService ক্লাসটিকে তৈরি করতে
          bind(DatabaseService.class).toInstance(new DatabaseService("jdbc:mysql://localhost/mydb"));
      }
  
      // Guice এ @PostConstruct এবং @PreDestroy সাপোর্ট করার জন্য
      @Provides
      @Singleton
      public DatabaseService provideDatabaseService() {
          return new DatabaseService("jdbc:mysql://localhost/mydb");
      }
  }
  

• এখানে, @Provides মেথডটি Guice কে বলে কিভাবে DatabaseService ইনস্ট্যান্স তৈরি করতে হবে এবং @Singleton দিয়ে এটি নিশ্চিত করা হয় যে ডাটাবেজ সার্ভিসের একটি মাত্র ইনস্ট্যান্স থাকবে।

• Step 4: Main ক্লাসে Guice Injector দিয়ে ইনজেক্ট করা

• import com.google.inject.Guice;
  import com.google.inject.Injector;
  
  public class Main {
      public static void main(String[] args) {
          Injector injector = Guice.createInjector(new AppModule());
          
          // DatabaseService ইনজেক্ট করা হচ্ছে
          DatabaseService databaseService = injector.getInstance(DatabaseService.class);
          
          // DatabaseService এর মেথড কল করা
          databaseService.query();
          
          // Guice অবজেক্টের lifecycle ধ্বংস হওয়ার সময় cleanup মেথড কল হবে
          injector.injectMembers(databaseService);
      }
  }
  

• এখানে, Guice Injector ব্যবহার করে DatabaseService ক্লাসের ইনস্ট্যান্স তৈরি হচ্ছে এবং @PostConstruct এবং @PreDestroy এর মাধ্যমে ইনিশিয়ালাইজেশন এবং ক্লিনআপ স্বয়ংক্রিয়ভাবে পরিচালিত হচ্ছে।

• ---

• @PostConstruct এবং @PreDestroy এর সুবিধা

• স্বয়ংক্রিয় Initialization এবং Cleanup:
  • @PostConstruct এবং @PreDestroy অ্যানোটেশন ব্যবহার করে কোডের জীবনচক্রের শুরু এবং শেষে নির্দিষ্ট মেথডগুলো স্বয়ংক্রিয়ভাবে কল হয়, যা কোডের পরিষ্কার এবং সংগঠিত রাখা নিশ্চিত করে।
• ডিপেনডেন্সি ম্যানেজমেন্ট:
  • এগুলি Guice বা অন্যান্য DI কনটেইনারে অবজেক্ট তৈরি এবং ধ্বংসের সময় নির্দিষ্ট কার্যকলাপ সম্পন্ন করতে সহায়তা করে, যেমন কনফিগারেশন লোড করা বা রিসোর্স ক্লিনআপ করা।
• কোডের কার্যকারিতা বৃদ্ধি:
  • এটি আপনার কোডকে আরও কার্যকরী এবং maintainable করে, কারণ অবজেক্টের ইনিশিয়ালাইজেশন ও ক্লিনআপ গুলি স্বয়ংক্রিয়ভাবে পরিচালিত হয়।

• ---

• Guice-এ @PostConstruct এবং @PreDestroy অ্যানোটেশন ব্যবহার করে আপনি অবজেক্টের জীবনচক্রের শুরু এবং শেষের সময় নির্দিষ্ট কার্যকলাপ স্বয়ংক্রিয়ভাবে সম্পাদন করতে পারেন। এগুলি object initialization এবং resource cleanup বা shutdown অপারেশনকে সহজ ও কার্যকরী করে তোলে। Guice-এর সাথে এই অ্যানোটেশনগুলি ব্যবহার করলে কোডের রিডেবিলিটি এবং টেস্টেবিলিটি বৃদ্ধি পায়।

Guice একটি শক্তিশালী Dependency Injection (DI) ফ্রেমওয়ার্ক যা ডিপেনডেন্সি ইনজেকশনের জন্য automatic lifecycle management প্রদান করে। তবে, কখনও কখনও আপনাকে কাস্টম লাইফসাইকেল ম্যানেজমেন্টের প্রয়োজন হতে পারে, যেমন একটি নির্দিষ্ট অবজেক্টের তৈরি হওয়া এবং ধ্বংস হওয়ার জন্য কাস্টম নিয়ম তৈরি করা। Guice আপনাকে এটি করার জন্য বিভিন্ন পদ্ধতি প্রদান করে।

এখানে, আমরা দেখব কিভাবে Guice-এ Custom Lifecycle Management তৈরি করা যায়, যাতে আপনি ডিপেনডেন্সিগুলির lifecycle (অবজেক্টের সৃষ্টি এবং ধ্বংস) কাস্টমাইজ করতে পারেন।

1. Guice-এ Lifecycle Management

Guice নিজেই singleton, scoped, এবং transient লাইফসাইকেলগুলো পরিচালনা করে, তবে কখনও কখনও আপনাকে custom lifecycle তৈরি করতে হতে পারে, যেখানে অবজেক্টের নির্মাণ এবং ধ্বংস আরও কাস্টমাইজড হবে।

এখানে কিছু custom lifecycle management কৌশল দেখানো হলো:

2. Guice-এ Custom Scope তৈরি করা

Guice-এ আপনি Custom Scopes তৈরি করতে পারেন, যা নির্দিষ্ট একটি অবজেক্টের লাইফসাইকেল নিয়ন্ত্রণ করবে। উদাহরণস্বরূপ, আপনি একটি request-scoped বা session-scoped অবজেক্ট তৈরি করতে পারেন।

ধাপ 1: Custom Scope তৈরি করা

এখানে একটি উদাহরণ দেখানো হলো যেখানে আমরা একটি CustomScope তৈরি করব।

import com.google.inject.Scope;
import com.google.inject.spi.ScopeAnnotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// Custom annotation for our scope
@Retention(RetentionPolicy.RUNTIME)
@ScopeAnnotation
public @interface CustomScope {}

// Custom scope implementation
public class CustomScopeImpl implements Scope {
    private static final ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    @Override
    public <T> com.google.inject.Provider<T> scope(Key<T> key, com.google.inject.Provider<T> unscoped) {
        return new com.google.inject.Provider<T>() {
            @Override
            public T get() {
                T instance = (T) threadLocal.get();
                if (instance == null) {
                    instance = unscoped.get();
                    threadLocal.set(instance);
                }
                return instance;
            }
        };
    }

    public static void clear() {
        threadLocal.remove();
    }
}

ধাপ 2: Custom Scope ব্যবহার করা

এখন আমরা CustomScope ব্যবহার করে একটি নির্দিষ্ট ইনস্ট্যান্স তৈরি এবং ব্যবহারের জন্য @CustomScope অ্যানোটেশন ব্যবহার করব।

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provider;
import com.google.inject.Singleton;

// Simple class for demonstration
public class MyService {
    private final String name;

    @Inject
    public MyService() {
        this.name = "Custom Scoped Service";
    }

    public String getName() {
        return name;
    }
}

// Guice Module
public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        // Install the custom scope
        bindScope(CustomScope.class, new CustomScopeImpl());
        bind(MyService.class).in(CustomScope.class);
    }
}

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new MyModule());

        // Create multiple instances of MyService
        MyService service1 = injector.getInstance(MyService.class);
        MyService service2 = injector.getInstance(MyService.class);

        // Both instances are the same because they are in the CustomScope
        System.out.println(service1.getName());
        System.out.println(service2.getName());
        System.out.println(service1 == service2);  // Output: true (singleton within CustomScope)
    }
}

Explanation:

• এখানে CustomScope তৈরি করা হয়েছে এবং এটি thread-local storage ব্যবহার করছে। এর মানে হল যে একে একে থ্রেডের মধ্যে একই অবজেক্ট ইনজেক্ট হবে।
• @CustomScope অ্যানোটেশন ব্যবহার করে MyService ক্লাসের ইনস্ট্যান্সটি CustomScope-এর মধ্যে থাকবে।

3. Guice Lifecycle Hooks

Guice আপনাকে custom lifecycle management করতে Lifecycle Hooks প্রদান করে, যেমন @PostConstruct এবং @PreDestroy অ্যানোটেশন ব্যবহার করে ডিপেনডেন্সির লাইফসাইকেল পরিচালনা করা।

ধাপ 1: @PostConstruct এবং @PreDestroy ব্যবহার

Guice-এর মাধ্যমে @PostConstruct এবং @PreDestroy লাইফসাইকেল হুকগুলো ব্যবহার করা যায়, যা অবজেক্টের তৈরি হওয়ার পরে এবং ধ্বংস হওয়ার আগে কিছু কাজ করতে সাহায্য করে।

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class LifecycleService {
    @PostConstruct
    public void init() {
        System.out.println("LifecycleService initialized");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("LifecycleService cleaned up");
    }

    public void serve() {
        System.out.println("Service is being served...");
    }
}

ধাপ 2: Guice Module-এ Lifecycle Hooks ব্যবহার

এখন, আমাদের Guice Module তৈরি করতে হবে এবং LifecycleService এর জন্য লাইফসাইকেল হুক ব্যবহার করতে হবে।

import com.google.inject.AbstractModule;

public class LifecycleModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(LifecycleService.class).asEagerSingleton();  // Create eagerly initialized singleton
    }
}

ধাপ 3: Injector-এ Lifecycle Management ব্যবহার

import com.google.inject.Guice;
import com.google.inject.Injector;

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new LifecycleModule());
        
        // Get instance of LifecycleService
        LifecycleService lifecycleService = injector.getInstance(LifecycleService.class);
        lifecycleService.serve();
        
        // Cleanup occurs when the application is shut down
        injector.getInstance(LifecycleService.class);  // Here cleanup would happen (on application exit)
    }
}

Explanation:

• @PostConstruct এবং @PreDestroy হুক ব্যবহার করে আমরা অবজেক্ট তৈরি হওয়ার পরে কিছু কাজ করতে এবং অবজেক্ট ধ্বংসের আগে কিছু কাজ করতে পারি।
• asEagerSingleton() ব্যবহার করলে Guice অবজেক্টটি তৈরি করার সময় @PostConstruct হুক কল করবে এবং অবজেক্ট ধ্বংস হওয়ার সময় @PreDestroy কল হবে।

4. Guice Lifecycle Management এর সুবিধা

1. Custom Scopes:
   • আপনি কাস্টম স্কোপ তৈরি করতে পারেন যেমন session-scoped, request-scoped, বা আরও কাস্টম স্কোপের জন্য ডিপেনডেন্সি ম্যানেজমেন্ট করতে পারেন।
   • এটি Guice-এ বিভিন্ন অবজেক্টের জন্য কাস্টম লাইফসাইকেল প্রয়োগ করার সুযোগ দেয়।
2. Explicit Initialization & Cleanup:
   • Lifecycle Hooks (@PostConstruct, @PreDestroy) ব্যবহার করার মাধ্যমে আপনি অবজেক্টের ইন্টিগ্রেশন আরও পরিষ্কারভাবে এবং নিয়ন্ত্রিতভাবে করতে পারেন।
   • কাস্টম ডেস্ট্রাকশন লজিক বা ইনিশিয়ালাইজেশন লজিক প্রয়োগ করা সহজ হয়।
3. Thread-Safe Lifecycle:
   • Thread-local scoping ব্যবহার করে, আপনি থ্রেডে বিশেষ লাইফসাইকেল ম্যানেজমেন্ট করতে পারেন, যা মাল্টিথ্রেডেড পরিবেশে গুরুত্বপূর্ণ।

• Custom Lifecycle Management Guice-এ অত্যন্ত নমনীয় এবং শক্তিশালী একটি ফিচার। আপনি custom scopes, lifecycle hooks, এবং thread-local storage ব্যবহার করে Guice-এর ডিপেনডেন্সি ইনজেকশন প্রক্রিয়াকে কাস্টমাইজ করতে পারেন।
• Guice আপনাকে dependency lifecycle আরও নিয়ন্ত্রিত এবং উপযুক্তভাবে পরিচালনা করার সুযোগ দেয়, বিশেষত যখন আপনি বিভিন্ন কাস্টম স্কোপ এবং ক্লিনআপ লজিক ব্যবহার করতে চান।