\documentclass{uebung}

\author{Linus Nagel}
\chapter{2}

\begin{document}

\maketitle

\begin{exercises}
    \item \textbf{Was ist eine Entity?}

    Eine Entity ist das Java-Pendant zu einem Datensatz aus der Datenbank. Es handelt sich um ein POJO (Plain Old Java Object), das mit der Annotation \texttt{@Entity} ausgezeichnet wird. Entities repräsentieren die Geschäftsobjekte bzw. die Daten einer Anwendung.

    \item \textbf{Wie wird eine Entity erstellt und welche Inhalte enthält eine Entity üblicherweise?}

    Eine Entity wird erstellt, indem eine gewöhnliche Java-Klasse mit \texttt{@Entity} annotiert wird. Üblicherweise enthält sie:
    \begin{itemize}
        \item Attribute (z.B. eine ID als Primärschlüssel, fachliche Daten)
        \item einen parameterlosen Konstruktor (zwingend)
        \item Getter und Setter für die Attribute
        \item Implementierung von \texttt{Serializable}
        \item optional \texttt{toString()}, \texttt{hashCode()}, \texttt{equals()}
    \end{itemize}

    \item \textbf{Durch welche Annotation wird ein Attribut als Primärschlüssel gekennzeichnet?}

    Mit \texttt{@Id}. Zusätzlich kann \texttt{@GeneratedValue} verwendet werden, um die automatische Generierung des Primärschlüssels zu ermöglichen.

    \item \textbf{Was ist ein EntityManager?}

    Der EntityManager ist die zentrale Schnittstelle der JPA für Datenbankoperationen. Er stellt Methoden zum Speichern, Suchen, Löschen und Bearbeiten von Entities bereit und synchronisiert diese mit der Datenbank.

    \item \textbf{Wie kann eine Klasse ein EntityManager-Objekt auslesen/erhalten?}

    Eine Klasse kann den EntityManager über Dependency Injection mittels der Annotation \texttt{@PersistenceContext} erhalten:
    \begin{minted}[breaklines]{java}
@PersistenceContext
private EntityManager em;
    \end{minted}
    Alternativ ist ein JNDI-Lookup möglich.

    \item \textbf{Welche Methode des EntityManagers wird verwendet um ein Objekt in der Datenbank anzulegen?}

    Die Methode \texttt{persist(Object entity)}. Beispiel: \texttt{em.persist(person);}

    \item \textbf{Was ist eine Persistence Unit und welche Datei wird verwendet um eine Persistence Unit zu definieren?}

    Eine Persistence Unit legt fest, welche Entities auf welche Weise (O/R-Mapping) auf die Datenbank abgebildet werden. Sie wird in der Datei \texttt{persistence.xml} im Ordner \texttt{META-INF} definiert.

    \item \textbf{Welche Zustände existieren im Lebenszyklus einer Entity?}

    Die Zustände sind:
    \begin{itemize}
        \item \textbf{New (transient):} Entity neu erzeugt, noch nicht mit Persistenzkontext verbunden.
        \item \textbf{Managed:} Entity wird vom Persistenzkontext verwaltet, Änderungen werden automatisch nachverfolgt.
        \item \textbf{Detached:} Entity nicht mehr im Persistenzkontext (z.B. nach Übergabe an den Client).
        \item \textbf{Removed:} Entity wurde zum Löschen markiert.
    \end{itemize}

    \item \textbf{Welchen Zustand hat eine Entity, die an einen Client übergeben wurde?}

    Sie befindet sich im Zustand \textbf{detached}.

    \item \textbf{Wie kann eine Entity, die an den Client übergeben wurde, wieder in den Zustand managed überführt werden?}

    Durch Aufruf der Methode \texttt{merge(entity)} des EntityManagers:
    \begin{minted}[breaklines]{java}
person = em.merge(person);
    \end{minted}
    Oder durch erneutes Laden mit \texttt{find(...)}.

    \item \textbf{Welche Rückgabe hat die Methode merge(…) und warum ist eine Rückgabe notwendig?}

    \texttt{merge(entity)} gibt eine verwaltete Instanz der Entity zurück. Die Rückgabe ist notwendig, weil die übergebene detached Entity nicht selbst zum managed Zustand wird, sondern der Persistenzkontext eine (möglicherweise andere) verwaltete Instanz liefert. Daher muss das Ergebnis der Variablen zugewiesen werden.

    \item \textbf{Worum handelt es sich beim Lazy loading?}

    Lazy Loading bezeichnet das verzögerte Laden von Attributen oder Assoziationen einer Entity erst dann, wenn sie tatsächlich verwendet werden. Es wird z.B. mit \texttt{@Basic(fetch=FetchType.LAZY)} oder \texttt{@OneToMany(fetch=FetchType.LAZY)} gesteuert und verbessert die Performance, da nicht alle Daten sofort aus der Datenbank geladen werden.

    \item \textbf{Welche Möglichkeiten gibt es um mittels O/R-Mapping Vererbung auf Tabellen abzubilden? Beschreiben Sie diese Strategien grob.}

    Es gibt drei Strategien, gesteuert durch \texttt{@Inheritance(strategy=...)}:
    \begin{itemize}
        \item \textbf{Single Table:} Die gesamte Vererbungshierarchie wird in einer Tabelle abgebildet. Eine Diskriminatorspalte (z.B. \texttt{DTYPE}) speichert den konkreten Typ. Vorteil: einfach, Nachteil: viele leere (\texttt{null}) Spalten.
        \item \textbf{Table per Class:} Für jede Entity (auch abstrakte) wird eine eigene Tabelle erzeugt, die alle Attribute der jeweiligen Klasse enthält. Vorteil: keine leeren Spalten, Nachteil: aufwendige Abfragen bei Polymorphie.
        \item \textbf{Joined:} Jede Klasse bekommt eine Tabelle. Die Tabellen der Unterklassen enthalten nur die zusätzlichen Attribute sowie eine Fremdschlüsselspalte auf die Tabelle der Oberklasse. Daten werden per Join zusammengesetzt. Vorteil: keine Redundanz, Nachteil: viele Joins bei tiefen Hierarchien.
    \end{itemize}

    \item \textbf{Mit welcher Annotation wird eine 1:1-Beziehung abgebildet?}

    Mit \texttt{@OneToOne} auf beiden Seiten der Beziehung.

    \item \textbf{Was ist die „owning side“ einer 1:1-Beziehung und wie kann sie festgelegt werden?}

    Die \textit{owning side} (führende Seite) ist diejenige Seite, die den Fremdschlüssel in der Datenbank erhält. Sie wird festgelegt, indem auf der anderen Seite das Attribut \texttt{mappedBy} gesetzt wird:
    \begin{minted}[breaklines]{java}
@OneToOne(mappedBy="auto")
private Lenkrad lenkrad;
    \end{minted}
    Die Klasse ohne \texttt{mappedBy} ist die owning side.

    \item \textbf{Welche Annotation erhält eine 1:n-Beziehung?}

    Die Annotation \texttt{@OneToMany} auf der Seite des Elternobjekts (z.B. \texttt{Fahrer} hat viele \texttt{Fahrt}).

    \item \textbf{Welche Annotation erhält eine n:1-Beziehung?}

    Die Annotation \texttt{@ManyToOne} auf der Seite des Kindobjekts (z.B. \texttt{Fahrt} referenziert einen \texttt{Fahrer}).

    \item \textbf{Welche ist in einer 1:n- oder n:1-Beziehung die owning side?}

    In einer 1:n- / n:1-Beziehung ist die \textbf{n:1-Seite} (die Seite mit \texttt{@ManyToOne}) immer die owning side. Sie erhält den Fremdschlüssel in der Datenbank. Auf der anderen Seite (1:n) verwendet man \texttt{@OneToMany(mappedBy=...)}.

    \item \textbf{Wie wird eine m:n-Beziehung annotiert?}

    Auf beiden Seiten wird \texttt{@ManyToMany} verwendet. Eine Seite muss \texttt{mappedBy} angeben, die andere ist die owning side. Es wird automatisch eine Relationstabelle generiert.

    \item \textbf{Wie kann eine Anfrage in JPQL erzeugt werden in der alle Objekte einer Klasse Auto abgefragt werden? Bitte geben Sie beispielhaft den Quellcode an.}

    \begin{minted}[breaklines]{java}
TypedQuery<Auto> query = em.createQuery("SELECT a FROM Auto a", Auto.class);
List<Auto> autos = query.getResultList();
    \end{minted}
    Oder kurz:
    \begin{minted}[breaklines]{java}
List<Auto> autos = em.createQuery("SELECT a FROM Auto a", Auto.class).getResultList();
    \end{minted}

    \item \textbf{Erstellen Sie eine Entity namens Mitarbeiter, die die fachlichen Attribute name (String) und personalnummer (int) enthält.}

    \noindent
    \inputminted[breaklines]{java}{../../server/src/main/java/org/example/demo/uebung2/aufgabe21/Mitarbeiter.java}

    \item \textbf{Erstellen Sie eine Stateless Session Bean, die eine Methode bereitstellt, die als Parameter ein Objekt der Klasse Mitarbeiter (aus Aufgabe 21) übergeben bekommt. Dieses Objekt soll durch die Methode in der Datenbank gespeichert werden. Die dabei generierte ID soll von der Methode zurückgeliefert werden. Testen Sie ihre Klassen durch einen geeigneten Client über das Remote Interface.}

    \textbf{Remote-Interface:}
    \inputminted[breaklines]{java}{../../server/src/main/java/org/example/demo/uebung2/aufgabe22/MitarbeiterServiceRemote.java}

    \textbf{Stateless Session Bean:}
    \inputminted[breaklines]{java}{../../server/src/main/java/org/example/demo/uebung2/aufgabe22/MitarbeiterService.java}

    \textbf{Standalone-Client:}
    \inputminted[breaklines]{java}{../../client/src/main/java/org/example/demo/uebung2/aufgabe22/Client.java}

    \textbf{persistence.xml:}
    \inputminted[breaklines]{xml}{../../server/src/main/resources/META-INF/persistence.xml}

\end{exercises}

\end{document}
