Composite Entity Pattern

The Composite Entity Pattern is used in the EJB persistence mechanism. A composite entity is an EJB entity bean that represents an object graph. When a composite entity is updated, internally dependent object beans are automatically updated because they are managed by the EJB entity bean. The following are the participants of the composite entity bean.

Composite EntityIt is the primary entity bean. It can be coarse-grained, or it can contain a coarse-grained object for persistent lifecycle.
Coarse-Grained ObjectThis object contains dependent objects. It has its own lifecycle and can also manage the lifecycle of dependent objects.
Dependent ObjectA dependent object is an object whose persistent lifecycle depends on the coarse-grained object.
Strategy (Strategies)The strategy indicates how the composite entity is implemented.

summary

intent

Convert tables in the database into composite objects in the application; these objects can represent a single record or a group of records in a table.

Main problem solved

Solve the problem of how to efficiently represent and manage complex data structures in the database during object-relational mapping, especially when one-to-many or many-to-many relationships exist.

Use Case

When database tables have complex relationships, or when there is a need to map database tables to composite objects in the application.

Implementation Approach

Composite Entity Class: Represents a table in the database, can contain a single record or a group of records.
Leaf Entity Class: Represents a single record in the table.
Container Entity Class: Represents a group of records in a table, can contain other leaf or container entities.

Key code

Composite Entity Class: Contains methods to add, delete, and access child entities.
Leaf Entity Class: Implements the composite entity interface, represents a single record.
Container Entity Class: Implements the composite entity interface, can contain multiple leaf or container entities.

Application example

Organizational Structure: An employee can be a leaf node, representing a single employee; a department can be a container node, containing multiple employees.

Advantages

Simplify data access: Simplifies access and management of database records through an object-oriented approach.
Improve code readability: Makes code closer to natural language, easy to understand and maintain.
Easy to Extend: Makes it easy to add new entity types or modify existing entities.

Disadvantages

Performance issues: Performance bottlenecks may be encountered when processing large amounts of data.
Complexity: May introduce unnecessary complexity for simple data models.

Usage suggestions

When you need to represent and manage complex data structures in a database, consider using the Composite Entity pattern.

Notes

Ensure that the use of the Composite Entity pattern does not introduce performance issues, especially when processing large amounts of data.

The main roles included.

Composite Entity：
- Represents a table in the database, can contain a single or multiple records.
Leaf Entity：
- Represents a single record in a table, does not contain child entities.
Container Entity：
- Represents a group of records in a table, can contain other leaf or container entities.
Data Access Object (optional)：
- Used to access and operate on the database, encapsulates data access logic.
Client (optional)：
- Use the Composite Entity pattern to access and operate on database records.

The Composite Entity pattern provides an intuitive and flexible way to handle complex data relationships by mapping database tables to objects in the application.

Implementation

We will create it as the composite entity.CompositeEntityObject.CoarseGrainedObjectIt is a class that contains dependent objects.

CompositeEntityPatternDemo, our demo class usesClientclass to demonstrate the usage of the Composite Entity Pattern.

Step 1

Create dependent objects.

DependentObject1.java

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

DependentObject2.java

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

Step 2

Create coarse-grained objects.

CoarseGrainedObject.java

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()}; } }

Step 3

Create composite entity.

CompositeEntity.java

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

Step 4

Create a client class that uses the composite entity.

Client.java

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

Step 5

UsageClientTo demonstrate the usage of the Composite Entity design pattern.

CompositeEntityPatternDemo.java

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(); } }

Step 6

Run the program, output the result:

Data: Test
Data: Data
Data: Second Test
Data: Data1

other extensions