设计模式笔记 – 组合实体模式

组合实体模式（Composite Entity Pattern）用在 EJB 持久化机制中。一个组合实体是一个 EJB 实体 bean，代表了对象的图解。当更新一个组合实体时，内部依赖对象 beans 会自动更新，因为它们是由 EJB 实体 bean 管理的。以下是组合实体 bean 的参与者。

• 组合实体（Composite Entity） – 它是主要的实体 bean。它可以是粗粒的，或者可以包含一个粗粒度对象，用于持续生命周期。
• 粗粒度对象（Coarse-Grained Object） – 该对象包含依赖对象。它有自己的生命周期，也能管理依赖对象的生命周期。
• 依赖对象（Dependent Object） – 依赖对象是一个持续生命周期依赖于粗粒度对象的对象。
• 策略（Strategies） – 策略表示如何实现组合实体。

示例

我们将创建作为组合实体的 CompositeEntity 对象。CoarseGrainedObject 是一个包含依赖对象的类。

CompositeEntityPatternDemo，我们的演示类使用 Client 类来演示组合实体模式的用法。

Java 实现

创建依赖对象

public class DependentObject1 {
    private String data;
    public void setData(String data) {
        this.data = data;
    }
    public String getData() {
        return data;
    }
}

public class DependentObject2 {
    private String data;
    public void setData(String data) {
        this.data = data;
    }
    public String getData() {
        return data;
    }
}

创建粗粒度对象

public class CoarseGrainedObject {
    DependentObject1 do1 = new DependentObject1();
    DependentObject2 do2 = new DependentObject2();
    public void setData(String data1, String data2) {
        do1.setData(data1);
        do2.setData(data2);
    }
    public String[] getData() {
        return new String[] {do1.getData(), do2.getData()};
    }
}

创建组合实体

public class ConpositeEntity {
    private CoarseGrainedObject cgo = new CoarseGrainedObject();
    public void setData(String data1, String data2) {
        cgo.setData(data1, data2);
    }
    public String[] getData(){
        return cgo.getData();
    }
}

创建使用组合实体的客户端类

public class Client {
    private ConpositeEntity conpositeEntity = new ConpositeEntity();
    public void printData() {
        String[] datas = (String[])conpositeEntity.getData();
        for (int i = 0; i < datas.length; i++) {
            System.out.println("Data: "+datas[i]);
        }
    }
    public void setData(String data1, String data2) {
        conpositeEntity.setData(data1, data2);
    }
}

使用 Client 来演示组合实体设计模式的用法

public class CompositeEntityPatternDemo {
    public static void main(String[] args) {
        Client client = new Client();
        client.setData("Test", "Data");
        client.printData();
        client.setData("Second Test", "Data1");
        client.printData();
    }
}

Python 实现

from typing import Tuple

class DependentObject1:
    def __init__(self):
        self.data = ''

    def set_data(self, data: str):
        self.data = data

    def get_data(self) -> str:
        return self.data

class DependentObject2:
    def __init__(self):
        self.data = ''

    def set_data(self, data: str):
        self.data = data

    def get_data(self) -> str:
        return self.data

class CoarseGrainedObject:
    def __init__(self):
        self.do1 = DependentObject1()
        self.do2 = DependentObject2()

    def set_data(self, data1: str, data2: str):
        self.do1.set_data(data1)
        self.do2.set_data(data2)

    def get_data(self) -> Tuple[str, ...]:
        return self.do1.get_data(), self.do2.get_data()

class CompositeEntity:
    def __init__(self):
        self.cgo = CoarseGrainedObject()

    def set_data(self, data1: str, data2: str):
        self.cgo.set_data(data1, data2)

    def get_data(self) -> Tuple[str, ...]:
        return self.cgo.get_data()

class Client:
    def __init__(self):
        self.composite_entity = CompositeEntity()

    def print_data(self):
        for data in self.composite_entity.get_data():
            print(f"Data: {data}")

    def set_data(self, data1: str, data2: str):
        self.composite_entity.set_data(data1, data2)

if __name__ == "__main__":
    client = Client()
    client.set_data("Test", "Data")
    client.print_data()
    client.set_data("Second Test", "Data1")
    client.print_data()