Was ist ein Domain Service in Java und wie wird er aufgerufen?

Ein Domain Service in Java ist ein Konzept aus der Domänengetrieben Entwicklung (Domain-Driven Design, DDD). Es sich um eine Klasse, die Geschäftslogik kapselt, die nicht direkt zu einem bestimmten Domänenobjekt gehört, sondern domänenübergreifend ist. Domain Services sind zustandslos und bieten Methoden an, die bestimmte Geschäftsoperationen ausführen.

### Beispiel für einen Domain Service

Angenommen, es gibt eine Domäne für ein E-Commerce-System, und es soll eine Logik implementiert werden, die den Gesamtpreis einer Bestellung berechnet. Diese Logik könnte in einem Domain Service gekapselt werden.

```java
public class OrderService {

public BigDecimal calculateTotalPrice(Order order) {
BigDecimal totalPrice = BigDecimal.ZERO;
for (OrderItem item : order.getItems()) {
totalPrice = totalPrice.add(item.getPrice().multiply(new BigDecimal(item.getQuantity())));
}
return totalPrice;
}
}
```

### Aufruf des Domain Services

Um den Domain Service in deinem Code aufzurufen, musst du eine Instanz des Services erstellen und die entsprechende Methode aufrufen. Hier ist ein Beispiel, wie das aussehen könnte:

```java
public class OrderController {

private OrderService orderService = new OrderService();

public void processOrder(Order order) {
BigDecimal totalPrice = orderService.calculateTotalPrice(order);
System.out.println("Total Price: " + totalPrice);
// Weitere Verarbeitung der Bestellung
}
}
```

### Verwendung von Dependency Injection

In einem realen Anwendungskontext, insbesondere in Enterprise-Anwendungen, wird oft Dependency Injection (DI) verwendet, um Instanzen von Services zu verwalten. Hier ist ein Beispiel mit Spring Framework:

```java
@Service
public class OrderService {

public BigDecimal calculateTotalPrice(Order order) {
BigDecimal totalPrice = BigDecimal.ZERO;
for (OrderItem item : order.getItems()) {
totalPrice = totalPrice.add(item.getPrice().multiply(new BigDecimal(item.getQuantity())));
}
return totalPrice;
}
}
```

```java
@RestController
public class OrderController {

private final OrderService orderService;

@Autowired
public OrderController(OrderService orderService) {
this.orderService = orderService;
}

@PostMapping("/processOrder")
public ResponseEntity<String> processOrder(@RequestBody Order order) {
BigDecimal totalPrice = orderService.calculateTotalPrice(order);
return ResponseEntity.ok("Total Price: " + totalPrice);
}
}
```

In diesem Beispiel wird der `OrderService` durch Spring's Dependency Injection Mechanismus in den `OrderController` injiziert. Dies erleichtert das Testen und die Wartung des Codes.