package eu.reply.lea.services.yms.task.tracking.observer; import…
- User
package eu.reply.lea.services.yms.task.tracking.observer;
import javax.enterprise.context.ApplicationScoped; import javax.enterprise.event.Observes; import javax.inject.Inject;
import java.time.Instant;
import eu.reply.lea.services.masterdata.reference.LocationReference; import eu.reply.lea.services.yms.task.tracking.AreaType; import eu.reply.lea.services.yms.task.tracking.QueueingStatusDTO; import eu.reply.lea.services.yms.task.tracking.LogisticUnitLocationTrackerService; import eu.reply.lea.services.yms.util.ObjectMapperUtility; import eu.reply.sce.backend.core.entity.EntityReference; import eu.reply.sce.backend.core.event.ModuleEvent; import eu.reply.sce.backend.core.event.Observer; import eu.reply.sce.backend.core.jee.log.Logged;
import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JsonNode; import org.slf4j.Logger;
@Observer @ApplicationScoped @Logged public class LogisticUnitLocationTrackerObserver {
@Inject private LogisticUnitLocationTrackerService logisticUnitLocationTrackerService; @Inject private Logger log; public void handleUpdateLocationTrackingInfo( @Observes @ModuleEvent("elementChangedAreaEvent") final JsonNode event) throws JsonProcessingException { EntityReference logisticUnitRef = ObjectMapperUtility.getMapper().treeToValue(event.path("externalEntityReference"), EntityReference.class); if ( logisticUnitRef.getEntityName().equals( "Container" ) || logisticUnitRef.getEntityName().equals( "Trailer" )) { log.info("Returning from elementChangedAreaEvent because entity name: {}", logisticUnitRef.getEntityName()); return; } Instant eventInstant = Instant.parse(ObjectMapperUtility.getMapper().treeToValue(event.path("eventInstant"), String.class)); String areaType = ObjectMapperUtility.getMapper().treeToValue(event.path("areaType"), String.class); LocationReference currentLocationReference = ObjectMapperUtility.getMapper().treeToValue(event.path("currentLocationReference"), LocationReference.class); LocationReference executionLocationReference = ObjectMapperUtility.getMapper().treeToValue(event.path("executionLocationReference"), LocationReference.class); QueueingStatusDTO queueingStatus = new QueueingStatusDTO(executionLocationReference, currentLocationReference, areaTypeConverter(areaType), eventInstant); logisticUnitLocationTrackerService.updateLocation(logisticUnitRef, queueingStatus); } public void updatePositionAfterDequeuedEvent(@Observes @ModuleEvent("updatePositionAfterDequeuedEvent") final JsonNode event) throws JsonProcessingException { EntityReference logisticUnitRef = ObjectMapperUtility.getMapper().treeToValue(event.path("queuedExternalEntityRef"), EntityReference.class); if ( logisticUnitRef.getEntityName().equals( "Container" ) || logisticUnitRef.getEntityName().equals( "Trailer" )) { log.info("Returning from elementChangedAreaEvent because entity name: {}", logisticUnitRef.getEntityName()); return; } logisticUnitLocationTrackerService.commandToUpdateLoadingUnitPosition(logisticUnitRef); } private AreaType areaTypeConverter(String areaType){ return AreaType.valueOf(areaType); }}
what do you think about : if ( logisticUnitRef.getEntityName().equals( "Container" ) || logisticUnitRef.getEntityName().equals( "Trailer" )) { log.info("Returning from elementChangedAreaEvent because entity name: {}", logisticUnitRef.getEntityName()); return; } with DDD how could i do this differently
- Assistant
The code you've provided includes a conditional check that relies on string comparisons to determine whether to proceed with processing:
if (logisticUnitRef.getEntityName().equals("Container") || logisticUnitRef.getEntityName().equals("Trailer")) { log.info("Returning from elementChangedAreaEvent because entity name: {}", logisticUnitRef.getEntityName()); return; }In terms of Domain-Driven Design (DDD) principles, this approach has several shortcomings:
-
String Comparisons Are Brittle: Using raw string comparisons can lead to errors due to typos, case sensitivity, and lack of compile-time checks. It also makes refactoring more difficult since renaming entities may not update string literals.
-
Lack of Expressiveness: The intent behind the check isn't immediately clear. Why are "Container" and "Trailer" excluded? This logic is hidden within the
ifstatement and isn't part of the domain model's explicit knowledge. -
Violation of Encapsulation: The logic for determining processability is scattered throughout the codebase rather than encapsulated within the domain model.
To align this code with DDD principles, you should consider modeling your domain explicitly and encapsulating domain logic within your entities or value objects. Here's how you might refactor your code:
1. Introduce a Domain Enumeration or Class Hierarchy
Create an enumeration or class hierarchy to represent the different types of logistic units. This replaces string literals with typed values, enhancing type safety and clarity.
Using an Enumeration:
public enum LogisticUnitType { CONTAINER, TRAILER, PALLET, BOX, // ... other types }Modify your
EntityReferenceclass to include this type:public class EntityReference { private LogisticUnitType logisticUnitType; // other fields... public LogisticUnitType getLogisticUnitType() { return logisticUnitType; } }Now, your conditional check becomes:
if (logisticUnitRef.getLogisticUnitType() == LogisticUnitType.CONTAINER || logisticUnitRef.getLogisticUnitType() == LogisticUnitType.TRAILER) { log.info("Returning from elementChangedAreaEvent because logistic unit type: {}", logisticUnitRef.getLogisticUnitType()); return; }Advantages:
- Type Safety: Enumerations provide compile-time checking, reducing the risk of errors.
- Clarity: The code clearly states that certain logistic unit types are excluded.
- Ease of Maintenance: Adding new types or renaming existing ones is simpler.
2. Encapsulate Logic Within Domain Model
Instead of having the logic scattered, encapsulate it within your domain model:
Within
EntityReference:public class EntityReference { private LogisticUnitType logisticUnitType; // other fields... public boolean isExcludedType() { return logisticUnitType == LogisticUnitType.CONTAINER || logisticUnitType == LogisticUnitType.TRAILER; } }In Your Observer:
if (logisticUnitRef.isExcludedType()) { log.info("Returning from elementChangedAreaEvent because logistic unit type: {}", logisticUnitRef.getLogisticUnitType()); return; }Advantages:
- Single Responsibility: The domain model is responsible for knowledge about its own state.
- Reusability: Other parts of your code can use
isExcludedType()without duplicating logic. - Testability: You can write unit tests for
isExcludedType()separately.
3. Use Polymorphism (If Appropriate)
If
ContainerandTrailershare certain behaviors or properties that distinguish them from other logistic units, consider using polymorphism:Define Base and Subclasses:
public abstract class LogisticUnit { // common fields and methods... public abstract boolean isProcessable(); } public class Container extends LogisticUnit { @Override public boolean isProcessable() { return false; } } public class Trailer extends LogisticUnit { @Override public boolean isProcessable() { return false; } } public class Pallet extends LogisticUnit { @Override public boolean isProcessable() { return true; } }In Your Observer:
if (!logisticUnitRef.isProcessable()) { log.info("Returning from elementChangedAreaEvent because logistic unit is not processable: {}", logisticUnitRef.getClass().getSimpleName()); return; }Advantages:
- Polymorphism: Behavior is determined by the object's type without explicit
ifstatements. - Extensibility: Adding new types with specific behaviors doesn't require changing existing code.
- Adherence to DDD Principles: Entities are responsible for their own behavior.
4. Apply the Specification Pattern
If the criteria for processability may change or become more complex, consider using the Specification Pattern.
Define a Specification:
public interface Specification<T> { boolean isSatisfiedBy(T t); } public class ProcessableLogisticUnitSpecification implements Specification<LogisticUnit> { @Override public boolean isSatisfiedBy(LogisticUnit logisticUnit) { return logisticUnit.isProcessable(); } }In Your Observer:
Specification<LogisticUnit> specification = new ProcessableLogisticUnitSpecification(); if (!specification.isSatisfiedBy(logisticUnitRef)) { log.info("Returning from elementChangedAreaEvent because logistic unit does not satisfy the processable specification"); return; }Advantages:
- Encapsulation of Business Rules: Specifications encapsulate business rules that can be reused and combined.
- Flexibility: Specifications can be modified without altering the domain entities.
- Testability: Specifications can be unit tested in isolation.
5. Leverage Domain Events and Handlers
In DDD, domain events can be used to signal state changes within the domain model. Event handlers can be registered to respond to specific events for specific entity types.
Define Specific Events:
public class ElementChangedAreaEvent implements DomainEvent { private final LogisticUnit logisticUnit; // other fields... public LogisticUnit getLogisticUnit() { return logisticUnit; } }Create Specific Handlers:
public class LogisticUnitEventHandler { public void handle(ElementChangedAreaEvent event) { LogisticUnit logisticUnit = event.getLogisticUnit(); if (!logisticUnit.isProcessable()) { log.info("Logistic unit is not processable: {}", logisticUnit.getClass().getSimpleName()); return; } // Process the event... } }Advantages:
- Separation of Concerns: Event handling logic is separated from other domain logic.
- Decoupling: Producers and consumers of events are decoupled.
- Scalability: It's easier to add new event handlers for different types without modifying existing code.
Conclusion
Refactoring your code according to DDD principles enhances maintainability, readability, and robustness. By modeling your domain explicitly and encapsulating logic within your domain entities:
- You reduce errors caused by string literals and scattered logic.
- You make your code self-expressive, as the domain model reflects the ubiquitous language of the domain.
- You facilitate future changes since adjustments to business logic are localized within the domain model.
Implementing these changes will make your codebase more aligned with DDD practices, leading to a more robust and maintainable system.
-