0Pricing
Clean Architecture & Design Patterns in Practice · درس

Prototype وObject Pool

تعلّم استخدام Prototype لاستنساخ الكائنات، وObject Pool لإدارة الموارد القابلة لإعادة الاستخدام بكفاءة.

Prototype وObject Pool درس مجاني في Clean Architecture & Design Patterns in Practice على CoddyKit. هذا هو الدرس 3 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Clean Architecture & Design Patterns in Practice، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Clean Architecture & Design Patterns in Practice 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

Welcome: Prototype & Object Pool

Welcome to this lesson on two powerful Creational Design Patterns: Prototype and Object Pool.

These patterns help us manage object creation efficiently, improving performance and resource utilization in our applications.

Understanding the Prototype Pattern

The Prototype pattern is about creating new objects by cloning an existing instance, rather than creating new ones from scratch. Think of it like a biological clone!

  • It's useful when object creation is complex or expensive.
  • It avoids the need for subclasses of factories to create objects.
  • It allows you to create many similar objects from a 'template' object.

Shallow vs. Deep Copy

When cloning objects, it's crucial to understand shallow copy vs. deep copy:

  • Shallow Copy: Creates a new object, but copies references to nested objects. Changes in the clone's nested objects will affect the original.
  • Deep Copy: Creates a new object and recursively creates new copies of all nested objects. The clone is completely independent of the original.

Prototype Example: Shallow Copy

In Java, the Cloneable interface and clone() method are used. This example shows a shallow copy, where changing the config in the clone also changes the original.

class Configuration {
  String setting;
  public Configuration(String setting) {
    this.setting = setting;
  }
}

class Report implements Cloneable {
  String name;
  Configuration config;

  public Report(String name, Configuration config) {
    this.name = name;
    this.config = config;
  }

  @Override
  protected Object clone() throws CloneNotSupportedException {
    return super.clone(); // Shallow copy
  }

  public void display() {
    System.out.println("Report: " + name + ", Setting: " + config.setting);
  }
}

public class Main {
  public static void main(String[] args) {
    Configuration initialConfig = new Configuration("Default");
    Report originalReport = new Report("Monthly Sales", initialConfig);

    try {
      Report clonedReport = (Report) originalReport.clone();
      clonedReport.name = "Quarterly Sales";
      clonedReport.config.setting = "Aggregated"; // Changes original's config!

      originalReport.display();
      clonedReport.display();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }
}

Prototype Example: Deep Copy

To achieve a deep copy, you must manually clone mutable fields within your clone() method. This ensures the original object's nested state is not affected.

class Configuration implements Cloneable {
  String setting;
  public Configuration(String setting) {
    this.setting = setting;
  }

  @Override
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

class Report implements Cloneable {
  String name;
  Configuration config;

  public Report(String name, Configuration config) {
    this.name = name;
    this.config = config;
  }

  @Override
  protected Object clone() throws CloneNotSupportedException {
    Report cloned = (Report) super.clone();
    cloned.config = (Configuration) config.clone(); // Deep copy for config
    return cloned;
  }

  public void display() {
    System.out.println("Report: " + name + ", Setting: " + config.setting);
  }
}

public class Main {
  public static void main(String[] args) {
    Configuration initialConfig = new Configuration("Default");
    Report originalReport = new Report("Monthly Sales", initialConfig);

    try {
      Report clonedReport = (Report) originalReport.clone();
      clonedReport.name = "Quarterly Sales";
      clonedReport.config.setting = "Aggregated"; // Only changes cloned's config

      originalReport.display();
      clonedReport.display();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }
}

When to Use Prototype?

Consider the Prototype pattern when:

  • Creating objects is resource-intensive (e.g., database queries, heavy computation).
  • You need to create many objects that are similar to an existing one.
  • You want to decouple your code from the concrete classes of objects you need to create.
  • You need to dynamically add or remove objects at runtime.

Introducing the Object Pool Pattern

The Object Pool pattern manages a set of initialized objects that are ready for use. It's like having a ready-to-go toolkit!

Instead of creating and destroying objects frequently, you 'borrow' them from the pool and 'return' them when done. This is especially useful for expensive resources.

How Object Pool Works

The core idea is to reuse objects. An Object Pool typically has:

  • Pool: A collection (e.g., a list) of available objects.
  • Acquire Method: Retrieves an object from the pool. If none are available, it might create a new one or wait.
  • Release Method: Returns an object to the pool, making it available for reuse.
  • Initialization: The pool can pre-create a certain number of objects at startup.

Object Pool Example

Here's a simple example of an Object Pool managing DatabaseConnection objects. Notice how connections are acquired and then released back to the pool.

import java.util.ArrayList;
import java.util.List;

class DatabaseConnection {
  private int id;
  public DatabaseConnection(int id) {
    this.id = id;
    System.out.println("Connection " + id + " created.");
  }

  public void connect() {
    System.out.println("Connection " + id + " connected.");
  }
}

class ConnectionPool {
  private List<DatabaseConnection> availableConnections = new ArrayList<>();
  private List<DatabaseConnection> inUseConnections = new ArrayList<>();
  private int maxPoolSize;
  private int counter = 0;

  public ConnectionPool(int maxPoolSize) {
    this.maxPoolSize = maxPoolSize;
  }

  public synchronized DatabaseConnection acquireConnection() {
    if (availableConnections.isEmpty() && inUseConnections.size() < maxPoolSize) {
      DatabaseConnection newConn = new DatabaseConnection(++counter);
      inUseConnections.add(newConn);
      return newConn;
    } else if (!availableConnections.isEmpty()) {
      DatabaseConnection conn = availableConnections.remove(0);
      inUseConnections.add(conn);
      return conn;
    } else {
      System.out.println("Pool is full, no connections available.");
      return null; // Or wait, throw exception
    }
  }

  public synchronized void releaseConnection(DatabaseConnection connection) {
    if (connection != null && inUseConnections.remove(connection)) {
      availableConnections.add(connection);
      System.out.println("Connection " + connection.id + " released.");
    } else {
      System.out.println("Attempted to release unknown connection.");
    }
  }
}

public class Main {
  public static void main(String[] args) {
    ConnectionPool pool = new ConnectionPool(2);

    DatabaseConnection conn1 = pool.acquireConnection();
    if (conn1 != null) conn1.connect();

    DatabaseConnection conn2 = pool.acquireConnection();
    if (conn2 != null) conn2.connect();

    DatabaseConnection conn3 = pool.acquireConnection(); // Should say pool is full

    pool.releaseConnection(conn1);
    DatabaseConnection conn4 = pool.acquireConnection(); // Should reuse conn1
    if (conn4 != null) conn4.connect();
  }
}

Benefits of Object Pool

Using an Object Pool offers significant advantages:

  • Performance: Reduces the overhead of object creation and garbage collection.
  • Resource Management: Controls the maximum number of active objects, preventing resource exhaustion.
  • Reduced Latency: Objects are ready immediately, without the delay of instantiation.
  • Improved Stability: Predictable resource usage.

Quick Check: Design Patterns

You have a complex ImageProcessor object that takes a long time to initialize due to loading large configuration files. You need to create many instances of this processor, each with slightly different parameters, but based on the same initial setup. Which design pattern would be most suitable for efficiently creating these new ImageProcessor instances?

Recap: Prototype & Object Pool

Great work! In this lesson, you learned about two powerful creational patterns:

  • Prototype: Creates new objects by cloning existing ones, useful for expensive or complex object instantiation. Remember the difference between shallow and deep copies!
  • Object Pool: Manages a collection of reusable objects, reducing the overhead of creating and destroying costly resources like database connections.

These patterns are key to building performant and resource-efficient applications!

الأسئلة الشائعة

هل درس «Prototype وObject Pool» مجاني؟

نعم — نص درس «Prototype وObject Pool» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Clean Architecture & Design Patterns in Practice، انتقل إلى CoddyKit PRO. تتضمن دورة Clean Architecture & Design Patterns in Practice 4 دروس في المجموع.

ماذا ستتعلم في «Prototype وObject Pool»؟

تعلّم استخدام Prototype لاستنساخ الكائنات، وObject Pool لإدارة الموارد القابلة لإعادة الاستخدام بكفاءة. تتمرن على Clean Architecture & Design Patterns in Practice مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Clean Architecture & Design Patterns in Practice؟

لا تُشترط خبرة سابقة. Clean Architecture & Design Patterns in Practice على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 3 من أصل 4.

كم من الوقت يستغرق درس «Prototype وObject Pool»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Clean Architecture & Design Patterns in Practice هذا؟

نعم. كل درس في Clean Architecture & Design Patterns in Practice يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

  1. Singleton وFactory Method
  2. Abstract Factory وBuilder
  3. Prototype وObject Pool
  4. حقن الاعتماديات كأسلوب إنشائي
← العودة إلى Clean Architecture & Design Patterns in Practice