Dependency Injection এর বেসিক কনসেপ্ট

Dependency Injection (DI) হলো Inversion of Control (IoC) ডিজাইন প্যাটার্নের একটি অংশ, যা অবজেক্টের মধ্যে ডিপেন্ডেন্সি পরিচালনার কাজ সহজ করে। এটি সফটওয়্যার ডেভেলপমেন্টে loose coupling নিশ্চিত করতে সাহায্য করে।

Dependency Injection (DI) এর ধারণা

DI এমন একটি পদ্ধতি, যেখানে একটি ক্লাসের প্রয়োজনীয় ডিপেন্ডেন্সি (অন্য ক্লাস বা অবজেক্ট) তৈরি এবং সরবরাহ করার দায়িত্ব ক্লাসের বাইরে স্থানান্তরিত করা হয়।

উদাহরণ:

একটি ক্লাস যদি অন্য একটি ক্লাসের উপর নির্ভরশীল হয়, তাহলে DI সেই নির্ভরশীল অবজেক্টটি সরাসরি তৈরি না করে বাইরে থেকে সরবরাহ করে।

Dependency Injection এর প্রয়োজনীয়তা

1. Loose Coupling (লুজ কাপলিং):
   DI ক্লাসগুলোর মধ্যে ডিপেন্ডেন্সি কমিয়ে ক্লাসগুলোকে আরও স্বাধীন ও পরিবর্তনযোগ্য করে তোলে।
2. Testability (টেস্টিং সহজ করে):
   DI ব্যবহার করলে মক অবজেক্ট তৈরি করে ইউনিট টেস্টিং করা সহজ হয়।
3. Code Maintenance (কোড রক্ষণাবেক্ষণ):
   কোড সহজে পরিবর্তন ও সম্প্রসারণযোগ্য হয়।
4. Reusability (পুনরায় ব্যবহার):
   DI ব্যবহার করলে কোড সহজেই পুনরায় ব্যবহার করা যায়।

Dependency Injection কিভাবে কাজ করে?

1. Constructor Injection

কনস্ট্রাক্টর ব্যবহার করে ডিপেন্ডেন্সি ইনজেক্ট করা হয়।
উদাহরণ:

class Service {
    private final Dependency dependency;

    // Constructor Injection
    public Service(Dependency dependency) {
        this.dependency = dependency;
    }

    public void execute() {
        dependency.perform();
    }
}

2. Setter Injection

সেটার মেথড ব্যবহার করে ডিপেন্ডেন্সি ইনজেক্ট করা হয়।
উদাহরণ:

class Service {
    private Dependency dependency;

    // Setter Injection
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }

    public void execute() {
        dependency.perform();
    }
}

3. Field Injection

সরাসরি ফিল্ডে ডিপেন্ডেন্সি ইনজেক্ট করা হয়। এটি সাধারণত annotations ব্যবহার করে করা হয়।
উদাহরণ (Guice):

class Service {
    @Inject
    private Dependency dependency;

    public void execute() {
        dependency.perform();
    }
}

Guice ব্যবহার করে Dependency Injection

Google Guice DI ফ্রেমওয়ার্ক ব্যবহার করে ডিপেন্ডেন্সি ইনজেকশন খুবই সহজ এবং কার্যকর। এটি মূলত annotations এবং modules ব্যবহার করে DI পরিচালনা করে।

Guice এর মাধ্যমে Constructor Injection:

import com.google.inject.*;

class Dependency {
    public void perform() {
        System.out.println("Dependency Executed!");
    }
}

class Service {
    private final Dependency dependency;

    @Inject
    public Service(Dependency dependency) {
        this.dependency = dependency;
    }

    public void execute() {
        dependency.perform();
    }
}

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

        // Dependency Injection
        Service service = injector.getInstance(Service.class);
        service.execute();  // Output: Dependency Executed!
    }
}

Guice Module ব্যবহার:

import com.google.inject.*;

class Dependency {
    public void perform() {
        System.out.println("Dependency Executed!");
    }
}

class Service {
    private final Dependency dependency;

    @Inject
    public Service(Dependency dependency) {
        this.dependency = dependency;
    }

    public void execute() {
        dependency.perform();
    }
}

class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Dependency.class).toInstance(new Dependency());
    }
}

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

        // Dependency Injection
        Service service = injector.getInstance(Service.class);
        service.execute();  // Output: Dependency Executed!
    }
}

Dependency Injection এর উপকারিতা

Dependency Injection এর চ্যালেঞ্জ

1. শিখতে সময় লাগে: নতুন ডেভেলপারদের জন্য DI ধারণা বুঝতে কিছুটা সময় লাগতে পারে।
2. Overhead: বড় প্রজেক্টে DI ফ্রেমওয়ার্ক ব্যবহারের ফলে পারফরম্যান্স কিছুটা কমতে পারে।
3. Debugging: DI ব্যবহারে runtime exception বা configuration issues ডিবাগ করা কঠিন হতে পারে।

Dependency Injection একটি গুরুত্বপূর্ণ ডিজাইন প্যাটার্ন যা loose coupling এবং testability নিশ্চিত করে। Guice-এর মতো ফ্রেমওয়ার্ক ব্যবহার করে এটি আরও সহজ এবং কার্যকর করা যায়। এটি বড় মাপের প্রজেক্টে কোডের জটিলতা কমিয়ে রক্ষণাবেক্ষণ সহজ করে।

Dependency Injection (DI) হল Inversion of Control (IoC) ডিজাইন প্যাটার্নের একটি গুরুত্বপূর্ণ অংশ, যা সফটওয়্যার ডেভেলপমেন্টে loosely coupled architecture তৈরি করতে সহায়তা করে। DI-এর মাধ্যমে একটি ক্লাসের প্রয়োজনীয় ডিপেনডেন্সি (অন্য ক্লাস বা অবজেক্ট) সরাসরি তৈরি না করে বাহ্যিক উৎস থেকে সরবরাহ করা হয়। এটি কোডের পুনঃব্যবহারযোগ্যতা, মডুলারিটি, এবং টেস্টিং সহজতর করে।

Dependency Injection (DI) এর ভূমিকা

1. Loose Coupling:
   • DI কোডের মধ্যে মডিউলগুলোর সম্পর্ককে শিথিল করে। ক্লাসগুলো সরাসরি একে অপরের উপর নির্ভর না করে নির্দিষ্ট ইন্টারফেস বা কন্ট্রাক্টের উপর নির্ভরশীল হয়।
2. Separation of Concerns (SoC):
   • DI একটি ক্লাসের প্রধান কাজ থেকে ডিপেনডেন্সি ম্যানেজমেন্ট আলাদা করে, ফলে কোড পরিষ্কার এবং আরও পড়তে সহজ হয়।
3. Configurable Components:
   • DI ব্যবহার করে ডিপেনডেন্সিগুলো বাইরের কনফিগারেশনের মাধ্যমে সহজেই মডিফাই বা পরিবর্তন করা যায়। উদাহরণস্বরূপ, একটি ডাটাবেস কানেকশন পরিবর্তন করা খুব সহজ হয়।
4. Testability:
   • DI মক বা স্টাব ডিপেনডেন্সি ইনজেক্ট করার মাধ্যমে সহজেই টেস্টিং করা যায়। এটি ইউনিট টেস্টের জন্য গুরুত্বপূর্ণ।
5. Code Reusability:
   • DI ক্লাসগুলোকে আরও পুনঃব্যবহারযোগ্য করে তোলে, কারণ এগুলো নির্দিষ্ট ডিপেনডেন্সির উপর নির্ভর না করে ইন্টারফেস বা কনফিগারেশনের উপর কাজ করে।

Dependency Injection এর প্রয়োজনীয়তা

a. Coupling কমানো:

• প্রথাগত পদ্ধতিতে একটি ক্লাস সরাসরি আরেকটি ক্লাসকে ইন্সট্যান্স করে, যা কোডের মধ্যে tight coupling তৈরি করে। DI এই সমস্যার সমাধান করে।

• উদাহরণ (Without DI):

  public class Service {
      private Repository repository = new Repository();
  }
  

  এখানে Service সরাসরি Repository এর উপর নির্ভরশীল, যা পরিবর্তনশীলতা কমায়।

b. কোডের মডুলারিটি বৃদ্ধি করা:

• DI ব্যবহার করলে ক্লাসগুলো আরও মডুলার হয়। উদাহরণস্বরূপ, একটি ইন্টারফেসের বিভিন্ন ইমপ্লিমেন্টেশন সহজেই ব্যবহার করা যায়।

• উদাহরণ (With DI):

  public class Service {
      private final Repository repository;
  
      public Service(Repository repository) {
          this.repository = repository;
      }
  }
  

c. Runtime Configuration:

• DI-এর মাধ্যমে নির্দিষ্ট ডিপেনডেন্সি runtime-এ সরবরাহ করা যায়, যা অ্যাপ্লিকেশনের কনফিগারেশন ক্ষমতা বৃদ্ধি করে।

d. সহজ টেস্টিং (Unit Testing):

• DI টেস্টিং সহজ করে তোলে, কারণ প্রয়োজনমতো মক ডিপেনডেন্সি ইনজেক্ট করা যায়।

• উদাহরণ:

  Repository mockRepository = new MockRepository();
  Service service = new Service(mockRepository);
  

e. Maintenance সহজ করা:

• DI কোড পরিবর্তন বা আপডেট করা সহজ করে, কারণ নতুন ডিপেনডেন্সি বা ইমপ্লিমেন্টেশন যোগ করলেও অন্য ক্লাসের পরিবর্তনের প্রয়োজন হয় না।

f. Reusability:

• DI কোডের পুনঃব্যবহারযোগ্যতা বাড়ায়, কারণ ডিপেনডেন্সিগুলি সরাসরি একে অপরের উপর নির্ভর না করে ইন্টারফেস বা কনফিগারেশনের মাধ্যমে ব্যবহৃত হয়।

Dependency Injection এর প্রকারভেদ

1. Constructor Injection:
   • ডিপেনডেন্সি সরাসরি কনস্ট্রাক্টরের মাধ্যমে সরবরাহ করা হয়।

   • উদাহরণ:

     public class Service {
         private final Repository repository;
     
         public Service(Repository repository) {
             this.repository = repository;
         }
     }
     

2. Setter Injection:
   • ডিপেনডেন্সি setter method এর মাধ্যমে ইনজেক্ট করা হয়।

   • উদাহরণ:

     public class Service {
         private Repository repository;
     
         public void setRepository(Repository repository) {
             this.repository = repository;
         }
     }
     

3. Field Injection:
   • ডিপেনডেন্সি সরাসরি ফিল্ডে ইনজেক্ট করা হয় (অ্যানোটেশন ব্যবহার করে)।

   • উদাহরণ:

     public class Service {
         @Inject
         private Repository repository;
     }
     

Dependency Injection এ Guice এর ভূমিকা

Guice হল একটি DI ফ্রেমওয়ার্ক যা DI প্যাটার্ন সহজ এবং কার্যকরভাবে ইমপ্লিমেন্ট করতে সাহায্য করে।

Guice দিয়ে Constructor Injection উদাহরণ:

1. ইন্টারফেস এবং ইমপ্লিমেন্টেশন:

   public interface Repository {
       void save();
   }
   
   public class RepositoryImpl implements Repository {
       @Override
       public void save() {
           System.out.println("Data saved!");
       }
   }
   

2. Module তৈরি:

   public class AppModule extends AbstractModule {
       @Override
       protected void configure() {
           bind(Repository.class).to(RepositoryImpl.class);
       }
   }
   

3. Service ক্লাস:

   public class Service {
       private final Repository repository;
   
       @Inject
       public Service(Repository repository) {
           this.repository = repository;
       }
   
       public void performTask() {
           repository.save();
       }
   }
   

4. Main অ্যাপ্লিকেশন:

   public class Application {
       public static void main(String[] args) {
           Injector injector = Guice.createInjector(new AppModule());
           Service service = injector.getInstance(Service.class);
           service.performTask();
       }
   }
   

Dependency Injection এর সুবিধা

1. Loose Coupling: ক্লাসের মধ্যে নির্ভরতা কম থাকে।
2. Improved Testability: সহজেই মক অবজেক্ট ব্যবহার করে টেস্ট করা যায়।
3. Reusability: কোড পুনরায় ব্যবহারযোগ্য।
4. Scalability: বড় অ্যাপ্লিকেশন স্কেল করা সহজ।
5. Maintainability: কোড মেনটেইন করা সহজ।

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

Guice হল গুগলের Dependency Injection (DI) ফ্রেমওয়ার্ক, যা Constructor Injection এবং Field Injection এর মতো বিভিন্ন DI প্যাটার্ন সহজে বাস্তবায়নের সুযোগ দেয়।

Constructor Injection

Constructor Injection হল এমন একটি প্যাটার্ন যেখানে নির্ভরশীলতাগুলি (dependencies) একটি ক্লাসের constructor এর মাধ্যমে ইনজেক্ট করা হয়। এটি সবচেয়ে জনপ্রিয় DI প্যাটার্ন, কারণ এটি:

• Immutable objects তৈরি করতে সহায়ক।
• ডিপেনডেন্সি স্পষ্টভাবে ঘোষণা করে, যা loose coupling নিশ্চিত করে।

Constructor Injection উদাহরণ

Step 1: Define Interfaces and Implementations

public interface Service {
    void serve();
}

public class ServiceImpl implements Service {
    @Override
    public void serve() {
        System.out.println("Service is serving...");
    }
}

Step 2: Use Constructor Injection

import com.google.inject.Inject;

public class Client {
    private final Service service;

    @Inject
    public Client(Service service) { // Constructor Injection
        this.service = service;
    }

    public void doSomething() {
        service.serve();
    }
}

Step 3: Create a Guice Module

import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Service.class).to(ServiceImpl.class); // Bind Interface to Implementation
    }
}

Step 4: Bootstrap the Application

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());
        Client client = injector.getInstance(Client.class); // Dependency Injected
        client.doSomething();
    }
}

Field Injection

Field Injection হল এমন একটি পদ্ধতি যেখানে নির্ভরশীলতাগুলি সরাসরি fields এ ইনজেক্ট করা হয়। এটি তখনই কার্যকর, যখন:

• নির্ভরশীলতা খুব বেশি সংখ্যা বা সহজ।
• ফিল্ডগুলোতে সরাসরি অ্যাক্সেস প্রয়োজন।

যদিও এটি Constructor Injection এর চেয়ে কম পছন্দ করা হয় কারণ:

• এটি encapsulation লঙ্ঘন করতে পারে।
• নির্ভরশীলতাগুলি ক্লাসের ভেতরে স্পষ্টভাবে ঘোষণা করা হয় না।

Field Injection উদাহরণ

Step 1: Define Interfaces and Implementations

public interface Service {
    void serve();
}

public class ServiceImpl implements Service {
    @Override
    public void serve() {
        System.out.println("Service is serving...");
    }
}

Step 2: Use Field Injection

import com.google.inject.Inject;

public class Client {
    @Inject
    private Service service; // Field Injection

    public void doSomething() {
        service.serve();
    }
}

Step 3: Create a Guice Module

import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Service.class).to(ServiceImpl.class); // Bind Interface to Implementation
    }
}

Step 4: Bootstrap the Application

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());
        Client client = injector.getInstance(Client.class); // Dependency Injected
        client.doSomething();
    }
}

Constructor Injection বনাম Field Injection

• Constructor Injection সাধারণত সবচেয়ে ভালো পদ্ধতি, কারণ এটি কোডকে আরও readable, testable, এবং maintainable করে।
• Field Injection বিশেষ ক্ষেত্রে ব্যবহার করা হয়, যেখানে নির্ভরশীলতাগুলির সংখ্যা বেশি এবং তাদের সরাসরি অ্যাক্সেস প্রয়োজন।

আপনার প্রয়োজন এবং স্থাপনার উপর ভিত্তি করে, উপযুক্ত DI পদ্ধতি বেছে নিন। Guice উভয় পদ্ধতিকে কার্যকরভাবে সমর্থন করে।

Dependency Injection (DI) এমন একটি নকশা প্যাটার্ন যা একটি শ্রেণির (class) উপর নির্ভরশীলতা (dependencies) সরাসরি ম্যানুয়ালি তৈরি না করে বাহ্যিক উৎস থেকে সরবরাহ করা হয়। Guice-এর মতো DI ফ্রেমওয়ার্ক ব্যবহার করে tight coupling সমস্যাগুলি সমাধান করা সম্ভব হয়।

Tight Coupling কী?

• Tight Coupling হল এমন একটি পরিস্থিতি যেখানে একাধিক শ্রেণি (classes) পরস্পরের উপর দৃঢ়ভাবে নির্ভরশীল।
• এর ফলে:
  • শ্রেণিগুলির পুনঃব্যবহারযোগ্যতা (reusability) হ্রাস পায়।
  • পরীক্ষণ (testing) কঠিন হয়ে যায়।
  • কোড মডিফাই করলে একটি শ্রেণির পরিবর্তন অন্য শ্রেণিতেও পরিবর্তন আনতে বাধ্য করে।

উদাহরণ:

public class BillingService {
    private final PaymentService paymentService;

    public BillingService() {
        this.paymentService = new PaypalPaymentService(); // Tight coupling
    }

    public void processPayment() {
        paymentService.pay();
    }
}

class PaypalPaymentService implements PaymentService {
    public void pay() {
        System.out.println("Payment made via PayPal.");
    }
}

interface PaymentService {
    void pay();
}

সমস্যা:

1. BillingService সরাসরি PaypalPaymentService-এর উপর নির্ভরশীল।
2. নতুন PaymentService যুক্ত করলে BillingService পরিবর্তন করতে হবে।

Guice এবং Dependency Injection-এর সমাধান

Guice Tight Coupling সমস্যার সমাধান করে Constructor Injection, Field Injection, এবং Method Injection ব্যবহার করে।

1. Constructor Injection

Guice @Inject ব্যবহার করে নির্ভরশীলতা ইনজেক্ট করতে সাহায্য করে।

import com.google.inject.Inject;

public class BillingService {
    private final PaymentService paymentService;

    @Inject
    public BillingService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processPayment() {
        paymentService.pay();
    }
}

2. Guice মডিউল এবং Binding

Guice AbstractModule ব্যবহার করে নির্ভরশীলতার রেজিস্ট্রেশন পরিচালনা করে।

import com.google.inject.AbstractModule;

public class BillingModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(PaymentService.class).to(PaypalPaymentService.class);
    }
}

3. Main Method: Guice Injector

Guice-এর মাধ্যমে Injector ব্যবহার করে BillingService তৈরি করুন।

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

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new BillingModule());
        BillingService billingService = injector.getInstance(BillingService.class);
        billingService.processPayment();
    }
}

Guice-এর মাধ্যমে Tight Coupling সমাধান

1. Interfaces ব্যবহার:
   • Guice নির্ভরশীলতাকে Interface দ্বারা নির্ধারণ করে, যা Implementation-এর উপর নির্ভরশীলতা কমায়।
2. Binding Decoupling:
   • BillingService ক্লাস সরাসরি নির্দিষ্ট PaymentService-এর উপর নির্ভর করে না।
   • Guice মডিউল নির্ধারণ করে কোন PaymentService ব্যবহার হবে।
3. পরিবর্তন এবং পরীক্ষণ সহজ:
   • নতুন PaymentService যোগ করা হলে শুধু মডিউলে bind পরিবর্তন করতে হবে।
   • Unit Testing-এ মক বা স্টাব (Mock/Stub) ব্যবহার করা সহজ।

Tight Coupling-এর উদাহরণ থেকে Loose Coupling-এ পরিবর্তন

Tight Coupling (Before Guice):

public class BillingService {
    private final PaymentService paymentService;

    public BillingService() {
        this.paymentService = new PaypalPaymentService(); // Tight Coupling
    }

    public void processPayment() {
        paymentService.pay();
    }
}

Loose Coupling (After Guice):

public class BillingService {
    private final PaymentService paymentService;

    @Inject
    public BillingService(PaymentService paymentService) {
        this.paymentService = paymentService; // Decoupled
    }

    public void processPayment() {
        paymentService.pay();
    }
}

Guice vs Traditional DI Approaches

• Guice DI Framework Tight Coupling সমস্যার কার্যকর সমাধান করে, যা ক্লাসগুলিকে আরো modular, flexible, এবং testable করে তোলে।
• Guice এর মাধ্যমে Constructor Injection ব্যবহার করলে শ্রেণিগুলির মধ্যে সরাসরি নির্ভরশীলতা দূর হয়।
• Guice শুধুমাত্র ছোট প্রজেক্ট নয়, বড় এবং জটিল প্রজেক্টেও কার্যকর যেখানে নির্ভরশীলতার সংখ্যা বেশি।
• Loose Coupling-এর জন্য Guice সহজ, লাইটওয়েট এবং কার্যকর সমাধান।

Loose Coupling (ডি-কাপলিং বা কম সম্পর্কযুক্ততা) সফটওয়্যার ডিজাইনে একটি গুরুত্বপূর্ণ কনসেপ্ট। এটি মানে হলো বিভিন্ন কম্পোনেন্ট বা ক্লাস পরস্পরের প্রতি কম নির্ভরশীল হবে। Guice (গুইস) ফ্রেমওয়ার্ক ব্যবহার করে Java অ্যাপ্লিকেশনে Loose Coupling সহজে বাস্তবায়ন করা যায়।

নিচে Guice ব্যবহার করে Loose Coupling কীভাবে অর্জন করা যায় তা ব্যাখ্যা করা হলো:

Loose Coupling এর প্রয়োজনীয়তা

1. কোডের মডুলারিটি: কোড সহজেই পুনর্ব্যবহারযোগ্য এবং মডিফাই করা যায়।
2. পরিবর্তনের সহজতা: কোনো একটি ক্লাস পরিবর্তন করলে অন্য ক্লাসগুলোতে এর প্রভাব কম হয়।
3. ইউনিট টেস্টিং: মক ডিপেন্ডেন্সি ব্যবহার করে সহজে ক্লাসগুলোর টেস্টিং করা যায়।

Guice এর মাধ্যমে Loose Coupling অর্জন করার প্রক্রিয়া

Guice ডিপেন্ডেন্সি ইনজেকশন (Dependency Injection) ব্যবহার করে Loose Coupling অর্জন করে। এতে নির্ভরশীলতা গুলি সরাসরি ক্লাসের ভিতর ইনস্ট্যানশিয়েট না করে বাইন্ডিং মডিউল এর মাধ্যমে সরবরাহ করা হয়। ফলে ক্লাসগুলোর মধ্যে সরাসরি সম্পর্ক থাকে না।

উদাহরণ: Loose Coupling Guice ব্যবহার করে

1. Interface এবং Implementation তৈরি করা

// Interface
public interface PaymentService {
    void processPayment(String amount);
}

// Implementation 1
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(String amount) {
        System.out.println("Processing credit card payment of: " + amount);
    }
}

// Implementation 2
public class PayPalPaymentService implements PaymentService {
    @Override
    public void processPayment(String amount) {
        System.out.println("Processing PayPal payment of: " + amount);
    }
}

2. Guice Module কনফিগার করা

import com.google.inject.AbstractModule;

public class PaymentModule extends AbstractModule {
    @Override
    protected void configure() {
        // Bind interface to a specific implementation
        bind(PaymentService.class).to(CreditCardPaymentService.class);
    }
}

3. ক্লাসে ডিপেন্ডেন্সি Inject করা

import com.google.inject.Inject;

public class OrderService {
    private final PaymentService paymentService;

    // Dependency injected through constructor
    @Inject
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder(String amount) {
        System.out.println("Placing order...");
        paymentService.processPayment(amount);
    }
}

4. অ্যাপ্লিকেশন চালানো

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

public class Application {
    public static void main(String[] args) {
        // Create Guice injector with PaymentModule configuration
        Injector injector = Guice.createInjector(new PaymentModule());

        // Get instance of OrderService with dependencies injected
        OrderService orderService = injector.getInstance(OrderService.class);

        // Place an order
        orderService.placeOrder("100 USD");
    }
}

Loose Coupling এর সুবিধাগুলো

1. ইন্টারফেসের মাধ্যমে কাজ:
   • ক্লাসগুলো সরাসরি একে অপরের সাথে সম্পর্কযুক্ত নয়। তারা ইন্টারফেসের মাধ্যমে কাজ করে।
2. Implementation পরিবর্তনের সুবিধা:
   • এক ইমপ্লিমেন্টেশন থেকে অন্য ইমপ্লিমেন্টেশনে পরিবর্তন করতে হলে শুধুমাত্র মডিউল পরিবর্তন করতে হয়, বাকি ক্লাসগুলোর কোনো কোড পরিবর্তনের প্রয়োজন নেই।
3. Unit Testing সহজ:
   • Guice এর মাধ্যমে মক ডিপেন্ডেন্সি ব্যবহার করে OrderService বা অন্য কোনো ক্লাস সহজেই টেস্ট করা যায়।

উদাহরণ:

bind(PaymentService.class).to(PayPalPaymentService.class);

উপরের এক লাইনের পরিবর্তনেই আমরা PayPalPaymentService ব্যবহার করতে পারি, কোনো অতিরিক্ত কোড পরিবর্তনের প্রয়োজন হয় না।

Guice Loose Coupling অর্জনের জন্য একটি অসাধারণ টুল। এটি অ্যাপ্লিকেশনের Maintainability এবং Scalability বাড়ায়। ইন্টারফেস এবং DI-এর মাধ্যমে Guice নিশ্চিত করে যে আপনার ক্লাসগুলো সরাসরি একে অপরের উপর নির্ভরশীল নয়। এটি সফটওয়্যার ডিজাইনে আধুনিক এবং কার্যকর পন্থা।