---
# System prepended metadata

title: Trading Service - Teil 1

---

# [**JEE 3-Tier Schichtenarchitektur**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764572056168190&cot=14)

> *1. Architektur des Gesamtsystems inkl. Spezifikation der Funktionen, die von den einzelnen Teilen zur Verfügung gestellt werden. Ordnen Sie dabei die von Ihnen zu erstellenden Artefakte in einem Architekturdiagramm der Java Enterprise Architektur zu. Sie können dabei auf dem 3-Tier Architurdiagramm von JEE aufbauen und dieses entsprechend projektspezifisch adaptieren und erweitern.*

![CSDC-VS-Architecture - 3 Tier Architecture](https://hackmd.io/_uploads/S1J1_qsST.jpg)

**Komponenten:**

1. Client: Hierbei handelt es sich um die Benutzerschnittstelle.
2. Web Container: WildFly stellt den Web Container bereit. 
3. EJB Container: WildFly beinhaltet auch den EJB Container, der die Enterprise JavaBeans hostet. 
4. Datenbankanbindung: stellt die JPA-Implementierung bereit, die für die Interaktion mit der Datenbank benötigt wird.
5. Datenbank (DB): Hier werden alle persistenten Daten gespeichert und verwaltet. 

# [**UML & Spezifikation der Funktionen**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571906699456&cot=14)

![Class UML](https://hackmd.io/_uploads/rkwTC8qSa.jpg)

# [**Presentation Tier**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571746011034&cot=14)

Die Präsentationsschicht ist in Java EE typischerweise durch Servlets, JSPs (JavaServer Pages) oder moderne Frameworks wie JSF (JavaServer Faces) repräsentiert. Diese Schicht ist für die Interaktion mit dem Endbenutzer zuständig.

![Presentation Tier](https://hackmd.io/_uploads/B1clywqrT.jpg)

**Client:** Generische  Benutzerklasse

**EmployeeClient:** JSF für die Benutzeroberfläche zur Interaktion mit dem Mitarbeiter.

**CustomerClient:** JSF für die Benutzeroberfläche zur Interaktion mit dem Kunden.

# [**Business Logic Tier**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571736101609&cot=14)

Diese Schicht enthält die Anwendungslogik, die die Geschäftsregeln und -prozesse implementiert. In Java EE wird sie durch EJBs (Enterprise JavaBeans) repräsentiert, die in einem EJB-Container wie WildFly oder JBoss gehostet werden.

![Business Logic Tier](https://hackmd.io/_uploads/B1z41PcHa.jpg)

**BankServer:** Verwaltet die Geschäftslogik wie das Suchen nach Aktien, Kaufen und Verkaufen von Aktien und die Aktualisierung des investierbaren Volumens.

**BankServerInterface** Eine Schnittstellendefinition für eine Stateless Session Bean, die keine Client-zustandsspezifischen Informationen zwischen Methodenaufrufen beibehält und für die Skalierbarkeit optimiert ist.

**BankServerImpl:** Die Implementierung der Geschäftslogik, welche die Methoden des BankServerInterface realisiert. Sie könnte als Stateless oder Stateful Session Bean implementiert werden, abhängig von der Notwendigkeit, den Zustand über mehrere Aufrufe hinweg zu erhalten.

**StockExchangeWebServiceClient:** Ein Client, der über JAX-WS (Java API for XML Web Services) mit einem externen Web Service kommuniziert, um Aktientransaktionen durchzuführen.

# [**Data Tier**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571904093041&cot=14)

Die unterste Schicht ist für die dauerhafte (persistente) Datenhaltung verantwortlich. In Java EE wird dies durch die Verwendung von JPA für die Objekt-Relationale Abbildung erreicht.

![CSDC-VS-Architecture - Data Tier](https://hackmd.io/_uploads/HJm0ENcra.jpg)

**PortfolioEntity, ClientEntity, TransactionEntity, StockEntity:** JPA-Entitätsklassen, die mit Annotationen wie @Entity, @Id, @OneToMany usw. versehen sind, um die Beziehungen und die Struktur der Datenbanktabellen zu definieren.

**DAOs (Data Access Objects):** Als Session Beans implementiert, verwenden den EntityManager von JPA, um CRUD-Operationen auf die Datenbank auszuführen. Sie können Methoden wie createClient(), getPortfolioByClientId() usw. enthalten.

# [**Mitarbeiter-Client**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571773452411&cot=10)
> *2. Design des Mitarbeiter-Clients inkl. Interaktionen mit dem Server*

Der "EmployeeClient" in der Präsentationsschicht des Three-Tier Architekturmodells ermöglicht Mitarbeitern die Interaktion mit dem System. Er bietet eine Benutzeroberfläche für Mitarbeiter und nutzt die Geschäftslogik und Daten, die in der Logik- und Datenschicht definiert sind. 

![Screenshot 2023-12-04 at 14.28.58](https://hackmd.io/_uploads/HyIVPUjHa.png)

**Methoden des EmployeeClient:**

- createCustomer(firstname, lastname, address, customerID): Ermöglicht die Erstellung eines neuen Kundenprofils.
- searchCustomer(customerId, firstname, lastname): Dient dem Auffinden von Kundeninformationen.
- searchStocks(): Ermöglicht das Suchen nach Aktieninformationen.
- buyStockForCustomer(customerId, stock, quantity): Erlaubt den Kauf von Aktien im Namen eines Kunden.
- sellStockForCustomer(customerId, stock, quantity): Ermöglicht den Verkauf von Aktien im Namen eines Kunden.
- searchStockForCustomer(customerId): Sucht nach Aktieninformationen spezifisch für einen Kunden.
- getPortfolioCustomer(customerId): Ruft das Portfolio eines bestimmten Kunden ab.
- queryInvestableVolume(): Ermittelt das investierbare Volumen.
- storeToken(String token), sendRequestWithToken(Request request): Diese Methoden sind für Authentifizierungszwecke und die sichere Übertragung von Anfragen.

**Der "Employee Client" ermöglicht folgendes:**

- **Identifikation:** Jeder Mitarbeiter wird durch eine employeeId identifiziert.
- **Serverinteraktion:** Das bankServerInterface stellt über entfernte Aufrufe die Verbindung zum Bankserver dar.

# [**Kunden-Client**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571746011057&cot=10)

> *3. Design des Kunden-Clients inkl. Interaktionen mit dem Server*

Im Kontext des Architekturdiagramms agiert der "CustomerClient" als Teil der Präsentationsschicht und bietet eine Schnittstelle für Kundeninteraktionen. Er kommuniziert mit der Logikschicht, wo Geschäftsprozesse über EJB-Komponenten abgewickelt werden.

![CosturmerClient](https://hackmd.io/_uploads/HytSlD5ra.jpg)

**Methoden des CustomerClient:**

- searchStocks(): Ermöglicht es dem Kunden, nach Aktien zu suchen.
- buyStock(stock, quantity): Dient dem Kauf von Aktien.
- sellStock(stock, quantity): Erlaubt den Verkauf von Aktien.
- getPortfolioCustomer(): Ruft das Kundenportfolio ab.
- storeToken(String token): Speichert ein Authentifizierungstoken.
- sendRequestWithToken(Request request): Sendet eine Anfrage mit einem Token.

**Der "CustomerClient" ermöglicht folgendes:**

- **Identifikation:** Kunden-ID, Vorname, Nachname und Adresse identifizieren den Kunden.
- **Serverinteraktion:** Das bankServerInterface stellt über entfernte Aufrufe die Verbindung zum Bankserver dar.

# [**JPA Entities**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571904093041&cot=14)

> *4. Spezifikation der am Bankserver* persistent verwalteten Daten (JPA Entities).

JPA-Entities repräsentieren die Objekte, die für die Speicherung und Verarbeitung von Daten in einer Datenbank in einer Java-Anwendung verwendet werden. Diese Entitäten werden normalerweise mit Annotationen wie @Entity, @Id, @Column, @Table, @OneToMany, @ManyToOne usw. versehen, um ihre Beziehungen zur Datenbank zu definieren und zu steuern, wie sie persistiert und abgefragt werden.

**1. PortfolioEntity**

![Screenshot 2023-12-04 at 17.49.20](https://hackmd.io/_uploads/r1r7mtoSa.png)

```
@Entity
@Table(name = "portfolios")
public class PortfolioEntity {
    
    @Id
    @Column(name = "portfolio_id")
    private Long portfolioId;
    
    @ManyToOne
    @JoinColumn(name = "client_id", referencedColumnName = "client_id")
    private ClientEntity client;
    
    // Die Map wird eine eigene Verknüpfungstabelle benötigen.
    @ElementCollection
    @CollectionTable(name = "portfolio_stocks", joinColumns = @JoinColumn(name = "portfolio_id"))
    @MapKeyJoinColumn(name = "stock_id")
    @Column(name = "quantity")
    private Map<StockEntity, Integer> stockShares;

    // Konstruktoren, Getter, Setter und weitere Methoden...
}
```

**2. ClientEntity**

![Screenshot 2023-12-04 at 17.51.00](https://hackmd.io/_uploads/HyHtXFjBp.png)

```
@Entity
@Table(name = "clients")
public class ClientEntity {
    
    @Id
    @Column(name = "client_id")
    private Long clientId;
    
    @Column(name = "username")
    private String username;
    
    @Column(name = "password")
    private String password;
    
    @Column(name = "email")
    private String email;
    
    @Column(name = "phone_number")
    private String phoneNumber;
}
```
**3. Transaction Entity**

![Screenshot 2023-12-04 at 17.52.40](https://hackmd.io/_uploads/Hk_yVtsrp.png)

```
@Entity
@Table(name = "transactions")
public class TransactionEntity {
    
    @Id
    @Column(name = "transaction_id")
    private Long transactionId;
    
    @ManyToOne
    @JoinColumn(name = "client_id", referencedColumnName = "client_id")
    private ClientEntity client;
    
    @ManyToOne
    @JoinColumn(name = "stock_id", referencedColumnName = "stock_id")
    private StockEntity stock;
    
    @Column(name = "quantity")
    private Integer quantity;
    
    @Column(name = "transaction_type")
    private String transactionType;
}
```

**4. Stock Entity**

![Screenshot 2023-12-04 at 17.53.59](https://hackmd.io/_uploads/BJbINtjST.png)

```
@Entity
@Table(name = "stocks")
public class StockEntity {
    
    @Id
    @Column(name = "stock_id")
    private Long stockId;
    
    @Column(name = "symbol")
    private String symbol;
    
    @Column(name = "company_name")
    private String companyName;
    
    @Column(name = "current_price")
    private Double currentPrice;
    
}
```

> *5. Remote Interface-Definition des Bankservers (inkl. typisierten Methodenparametern) und Festlegung der Technologie (RMI oder Web Services).*

# [**Interface-Definition**](https://miro.com/app/board/uXjVNIN4r84=/?moveToWidget=3458764571736101609&cot=14)






