@Entity Klassen, Service Beans etc. aus einem Share Projekt beziehen?

[internet]

Hallo zusammen,

ich würde gerne ein weiteres Java Projekt anlegen, in welchem ich Dinge implementiere, die ich bei weiteren Projekten benötige.
Also Implementierungen, Entities, Service Klassen etc., die ich dann in neuen Projekten nicht jedes Mal kopieren / neu einfügen muss...
Dieses Projekt füge ich dann einfach via Maven bei meinen anderen Projekten ein.

Darunter zählen dann:
1. verschiedene Entities (JPA), die ich in einem Projekt benötige (TriggerType, ActionType, Logging Tabelle...)
-> Wenn ich es richtig sehe, dann muss aber die @Entity - Klasse jeweils im eigenen Projekt sein und kann nicht von einem Unterprojekt (was ich dann via Maven importiere)
eingefügt werden? Jedenfalls hat mein erster Versuch dazu nicht geklappt und die Tabellel wurde in der DB nicht angelegt?
D.h. ich benötige ein Interface dieser Klasse und implementiere dann in den jeweiligen Projekten für die Entity das Interface?

2. Die Service - Klasse für die Datenbank, sodass das Objekt in der DB angelegt wird, inkl. Query Methoden, um die Objekte in der DB zu suchen.
-> Kann ich @Stateless annotierte Klassen aus dem Unterprojekt überhaupt verwenden?
-> Kann ich den EntityManager aus dem Unterprojekt nutzen?

3. Auch JSF Controller Klassen würde ich gerne in diesem Share Projekt haben

Wie gehe ich hier am Besten vor?

 

[LimDul]

Das funktioniert alles - muss man halt nur richtig machen

Das heißt, man muss dafür sorgen, dass die entsprechenden Klassen auch korrekt eingebunden werden. In JEE heißt das z.B. das die Entitäten in der entsprechenden persistence.xml drin sind. In Spring Boot müssen sie vom Komponentenscan gefunden werden - der läuft standardmäßig auf allen Packages unterhalb des Packages, wo die Application drin liegt. Den muss man dann - wenn die Packages im anderen Projekt anders aussehen - entsprechend konfigurieren.

Grundsätzlich es (fast) egal ob die anderen Projekte als Dependency eingebunden sind oder der Code im gleichen Projekt liegt.

 

[internet]

Das funktioniert alles - muss man halt nur richtig machen
In JEE heißt das z.B. das die Entitäten in der entsprechenden persistence.xml drin

Ich habe noch nie Entities hier hinzugefügt...
Muss ich diese explizit hier hinzufügen, wenn sie aus einem anderen Projekt kommen?

 

[LimDul]

So, wie es der Standard, den du verwendest, vorgibt. JEE? Spring Boot? ...?

 

[internet]

So, wie es der Standard, den du verwendest, vorgibt. JEE? Spring Boot? ...?

Ich verwende JEE...

 

[LimDul]

Dann wäre die Frage, wie da der Entity Lookup bisher funktioniert bei dir. Kommt ein WAR raus, was auf den Application Server deployed wird? Wo ist der persistence Context / die Persistence Unit definiert? Welches JPA Framework (Hibernate, Eclipselink, ...) wird verwendet?

 

[LimDul]

Hier sind ein paar Infos: https://thorben-janssen.com/jpa-persistence-xml/

 

[internet]

Ich habe eine persistence.xml, in der aber nur Connection stehen.

Ja, ich generiere eine WAR, was auf dem APP Server deployed wird.
Ich verwende Hibernate.

Die persistence.xml sieht so aus:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
    xmlns="http://xmlns.jcp.org/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
        http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">

    <persistence-unit name="primary">
        <jta-data-source>java:jboss/datasources/myapp</jta-data-source>
        <properties>

            <!-- Properties for Hibernate -->
            <property name="hibernate.hbm2ddl.auto" value="update" />

            <property name="hibernate.show_sql" value="false" />

            <property name="hibernate.format_sql" value="true" />

            <property name="hibernate.jdbc.batch_size" value="100000000" />

            <property name="hibernate.dialect"
                value="org.hibernate.dialect.MySQL8Dialect" />

            <property name="hibernate.connection.driver_class"
                value="com.mysql.cj.jdbc.Driver" />

            <property name="hibernate.connection.url"
                value="jdbc:mysql://localhost:3306/myapp?serverTimezone=Europe/Berlin&amp;useSSL=false" />

            <property name="hibernate.connection.username" value="root" />

            <property name="hibernate.connection.password"
                value="test1234" />

            <!-- Hibernate Envers -->
            <property name="hibernate.integration.envers.enabled"
                value="true" />
            <property name="hibernate.envers.autoRegisterListeners"
                value="false" />


        </properties>
    </persistence-unit>
</persistence>

In meinen Beans verwende ich dann entsprechend:

    @PersistenceContext
    private EntityManager entityManager;

 

[LimDul]

Dann das mal lesen: https://thorben-janssen.com/jpa-per...ged_classes_included_in_your_persistence_unit

 

[internet]

ok, danke...

Nun noch eine weitere Frage:
- Ich habe zwei Projekte:
a) ShareProject (hat die Klassen, Entities, die in den anderen Projekten genutzt wird)
b) MyProject (Projekt, das die Klassen, Entities von ShareProject nutzt)

In ShareProject baue ich mir eine entsprechende Struktur des Datenmodells bereits auf.
So habe ich bpsw: die Entites:

• User
• Project

Nun möchte ich aber in meinem "MyProject" die Entität "User" überschreiben oder weitere Felder implementieren.
Wenn ich keine neue Klasse (Entity) "User" in "MyProject" verwende, soll einfach die Entity "User" aus dem "ShareProject" verwendet werden.

Wie mache ich das denn?
Denn in ShareProject habe ich ja die Entität User bereits implementiert.

@Entity
@Table(name = "user")
public class User implements Serializable {
    ...
}

Alle Referenzen im ShareProject beziehen sich ja auf diese Klasse bereits.
Hier bpsw. bei der Entites "Project", in der ich eine Beziehung erstelle:

    // User
    @NotNull
    @ManyToOne
    @JoinColumn(name = "user_fk", nullable = false)
    private User user;

Ich hatte auch schon probiert anstatt der Entity ein Interface zu nutzen, aber da bekomme ich einen JPA Fehler, da es die Entity nicht gibt...

    // User
    @NotNull
    @ManyToOne
    @JoinColumn(name = "user_fk", nullable = false)
    private UserInterface user;

Prinzipiell möchte ich die Entities so gestalten, dass sie vom "MyProject" überschrieben werden könnten, sodass ich eine Flexibilität in der Implementierung habe. Wenn ich diese nicht überschreibe im "MyProject", soll eben die Entity aus dem "ShareProject" verwendet werden...

Eine Idee?

 

[LimDul]

Dann leite die einfach ab. Mach eine Ableitung von User und du bist quasi fertig. Musst nur die User Klasse entsprechend annotieren, dass für JPA klar ist, dass sie abgeleitet werden kann. Hier sind Varianten beschrieben: https://www.baeldung.com/hibernate-inheritance

 

[internet]

Ja, das habe ich bereits gesehen...
Ich bin mir aber nicht so ganz sicher, wie das aussehen soll..

in meinem ShareProject habe ich das:

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@Table(name = "user", indexes = { @Index(columnList = "user_id, id_hash") })
public class User implements Serializable, EntityPropertyFinder, UserInterface, Cloneable {

Referenzen gehen in diesem Projekt dann eben so:

    // User
    @NotNull
    @ManyToOne
    @JoinColumn(name = "user_fk", nullable = false)
    private User user;

In meinem "MyProject" habe ich dann:

@Entity
public class UserCustom extends User{
   
}

Ist das so korrekt?
Woher weiß mein "ShareProjekt" nun, dass ich UserCustom bei der Referenz nutzen möchte, und nicht nur "User" ?

 

[LimDul]

setUser(new UserCustom())

Du musst natürlich entsprechend Casts nach dem getter machen. Aber du hast da dann halt UserCustom Objekte drin.

 

[internet]

setUser(new UserCustom())

Du musst natürlich entsprechend Casts nach dem getter machen. Aber du hast da dann halt UserCustom Objekte drin.

wo genau meinst du das? Im "ShareProject" oder "MyProject" ?

Also nochmal:

ShareProject:

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@Table(name = "user", indexes = { @Index(columnList = "user_id, id_hash") })
public class User implements Serializable, EntityPropertyFinder, UserInterface, Cloneable {

    // Entsprechende Felder + Getter und Setter
  
}

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@Table(name = "project", indexes = { @Index(columnList = "project_id, id_hash") })
public class Project implements Serializable, EntityPropertyFinder, ProjectInterface, Cloneable {


    // Entsprechende Feler + Getter und Setter

    // User
    @NotNull
    @ManyToOne
    @JoinColumn(name = "user_fk", nullable = false)
    private User user;

}

MyProject:

@Entity
public class UserCustom extends User{
   // Wird vererbt
 
   private String testField;
 
   // Getter Setter für testField
}

Geht das so? Wo genau meinst du mit den Casts?

Woher weiß mein ShareProject nun, dass ich in der Referenz "UserCustom" verwende und nicht "User" ?
Es soll eben sichergestellt werden, dass wenn ich in "MyProject" UserCustom verwende, dass alle Referenzen in in "ShareProject" dann auf "UserCustom" gehen und nicht "User"...

 

[LimDul]

Das ist dann ein User-Problem und kein JPA Problem.

Es soll eben sichergestellt werden, dass wenn ich in "MyProject" UserCustom verwende, dass alle Referenzen in in "ShareProject" dann auf "UserCustom" gehen und nicht "User"...

Die Felder werden immer noch den Typ user haben. Das kannst du nicht ändern.

Was du machen kannst:
* Ableitung der Klasse und den Getter & Setter überscheiben, dass dort die Typen geprüft werden, dass nur UserCustom reinpackt.

An irgendeiner Stelle erzeugst du deine User-Objekte. Das ist die Stelle, wo du in MyProject sicherstellen musst, dass dort nur UserCustom erzeugt werden.

Das ist kein Problem mit JPA oder Entitäten sondern klassische Polymorphie.

 

[internet]

hm.

geht das dann durch Interfaces in den Setter / Getter von der Entity - Klasse im Shared Projekt?

SharedProject:

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@Table(name = "project", indexes = { @Index(columnList = "project_id, id_hash") })
public class Project implements Serializable, EntityPropertyFinder, ProjectInterface, Cloneable {

    // User
    @NotNull
    @ManyToOne
    @JoinColumn(name = "user_fk", nullable = false)
    private User user;

    // Getter + Setter
    public UserInterface getUserNext() {
        return userNext;
    }

    public void setUserNext(UserInterface userNext) {
        this.userNext = (User) userNext;
    }
    
}

-> private User user referenziert dann immer noch auf die Entity im Shared Projekt....

Dann habe ich ja die Klasse UserCustom, in der ich bpsw. ein weiteres Feld hinzufügen...

@Entity
public class UserCustom extends User{
  
   // Zb zusätzliches Feld...
   private String testField;
 
   // Getter Setter für testField
}

Nun kann ich ja:

Project project = new Project();
project.setUser(new UserCustom);

 

[Oneixee5]

Ich möchte dazu folgendes zu bedenken geben. Wenn in einer Entity z.B.: eine Spalte einmal definiert ist, dann wirst du diese nie mehr los. Du kannst diese ja nicht einfach "enterben". Bindest du die Entity in ein anderes Projekt ein, dann musst du die DB-Spalten immer anlegen, auch wenn diese nicht benötigt werden. Ansonsten wird deine Anwendung nicht starten. Bei einer Entity wie User ist es wahrscheinlich, dass diese auch in Fremdschlüsseln verwendet wird. Will man also eine Spalte aus User mal nicht in der DB haben, muss man in der Konfiguration alles rausschmeißen, was irgendwie mit User zu tun hat, auch alle Referenzen. Da User wahrscheinlich nicht die einzige betroffene Tabelle sein wird, ist es auch wahrscheinlich, dass das ganze importierte Schema nicht funktionieren wird.
Das ist sicher kein Problem wenn du mehrere Anwendungen bauen willst, welche auf die selbe DB zugreifen sollen. Das ist aber eher eine nicht so optimale Architektur.

 

[internet]

Ich möchte dazu folgendes zu bedenken geben. Wenn in einer Entity z.B.: eine Spalte einmal definiert ist, dann wirst du diese nie mehr los. Du kannst diese ja nicht einfach "enterben". Bindest du die Entity in ein anderes Projekt ein, dann musst du die DB-Spalten immer anlegen, auch wenn diese nicht benötigt werden. Ansonsten wird deine Anwendung nicht starten. Bei einer Entity wie User ist es wahrscheinlich, dass diese auch in Fremdschlüsseln verwendet wird. Will man also eine Spalte aus User mal nicht in der DB haben, muss man in der Konfiguration alles rausschmeißen, was irgendwie mit User zu tun hat, auch alle Referenzen. Da User wahrscheinlich nicht die einzige betroffene Tabelle sein wird, ist es auch wahrscheinlich, dass das ganze importierte Schema nicht funktionieren wird.

Genau deshalb möchte ich das SharedProjekt so aufbauen, dass man die Klasse überschreiben kann.
Ob die Entity verwendet wird oder nicht, geschieht ja dann auch über die persistence.xml...

Im Grunde geht es mir darum, dass ich nicht zig mal den gleichen Code in den Projekten haben muss.
Habe ich bspw. 3 verschiedene Projekte:

• Forum
• Ticketsystem
• Webshop

Dann habe ich immer:

• Benutzerverwaltung
• Berechtigungsverwaltung
• Benachrichtungsverwaltung
• Applikationseinstellungen
• .....

 

[Oneixee5]

Ob die Entity verwendet wird oder nicht, geschieht ja dann auch über die persistence.xml...

Du kannst eine Entity aus einem Fremdschlüssel nicht einfach in der persistence.xml auslassen.

Ich will dich auch nicht kritisieren oder dir etwas ausreden. Ich wollte dir nur einen Hinweis zu einem Sachverhalt geben, über den du genau nachdenken solltest.
Schon ein abweichender Spaltentyp könnte eine ganze Kette von Entities unbrauchbar machen, wenn Fremdschlüssel vorhanden sind. Fremdschlüssel wirst du aber brauchen, z.B.: für Queries oder einfach damit die Daten konsistent bleiben.

 

[internet]

Du kannst eine Entity aus einem Fremdschlüssel nicht einfach in der persistence.xml auslassen.

Ich will dich auch nicht kritisieren oder dir etwas ausreden. Ich wollte dir nur einen Hinweis zu einem Sachverhalt geben, über den du genau nachdenken solltest.
Schon ein abweichender Spaltentyp könnte eine ganze Kette von Entities unbrauchbar machen, wenn Fremdschlüssel vorhanden sind. Fremdschlüssel wirst du aber brauchen, z.B.: für Queries oder einfach damit die Daten konsistent bleiben.

Nunja... was wäre dein Gegenvorschlag? Doch alle Klassen, Methoden etc. jeweils in den einzelnen Projekten?

 

[Oneixee5]

Einen Gegenvorschlag habe ich nicht und weiß es auch nicht besser.

 

[thecain]

"The evils of too much coupling between services are far worse than the problems caused by code duplication" Sam Newman - building microservices

Ich würde mit dem doppelten Code leben. Vor allem dann, wenn du das Entity selber verwendest oder gar erweiterst. Eine Ausnahme könnte ich mir vorstellen, wenn die Library die Entities selber verwendet und via Services den Zugriff kapselt.

 

[internet]

Eine Ausnahme könnte ich mir vorstellen, wenn die Library die Entities selber verwendet und via Services den Zugriff kapselt.

Wie meinst du das genau?
Die Lib (SharedProjekt) verwendet die Entities ja auch...
Das Hauptproblem besteht primär in den Referenzen im SharedProjekt...

So wie ich es hier aufgezeigt habe:

https://www.java-forum.org/thema/entity-klassen-service-beans-etc-aus-einem-share-projekt-beziehen.200616/#post-1336840

Im SharedProjekt habe ich Klassen wie:

• Permission
• ScheduleExecution

Diese nutzen eben teilweise eine Referenz auf die Entity "User":

// User
@NotNull
@ManyToOne
@JoinColumn(name = "user_fk", nullable = false)
private User user;

Wenn ich die Klasse in meinem anderen Projekt nich überschreiben möchte, dann wäre es eher unproblematisch.

Ich bräuchte also irgendwie in diesem Code (siehe Code für @ManyToOne) einen Platzhalter für "User", was dann UserCustom ist oder wenn ich die Klasse nicht überschreibe dann einfach die Klasse User aus dem SharedProjekt nehme

 

[thecain]

Ja, das ist eben nicht gekapselt. Ein Zugriff auf das Entity passiert NUR via Service der auch in der lib lebt. Der Service gibt dann auch nicht das Entity nach aussen, sondern ein DTO.

Ich habe mit anderen Ansätzen bisher nur schlechte Erfahrungen gemacht. Das heisst aber nicht unbedingt, dass es dir gleich gehen muss.

 

[internet]

Ich habe das jetzt mal exemplarisch aufgezeichnet nur für einen Fall. Wie gesagt, da stecken etliche andere Klassen sonst noch dahinter (Rechteverwaltung usw.).

Shared Project hat die Entities:

• Project
• User

Überschreibe ich in "MyProject" die Klasse "User", dann soll innerhalb SharedProject die Referenz auf UserCustom gehen.
Das Problem ist aber natürlich, dass "SharedProject" die Klasse "UserCustom" gar nicht kennt.
Wie gesagt, ich habe auch schon sowas probiert, dass ich anstatt "User" ein Interface als Typ in der Referenz angebe. Das mag aber Hibernate / JPA nicht...

// User
@NotNull
@ManyToOne
@JoinColumn(name = "user_fk", nullable = false)
private UserInterface user;

Das muss doch irgendwie möglich sein?

 

[Oneixee5]

Möglicherweise liegt die Lösung woanders. Ich könnte mir z.B.: ein Maven-Plugin vorstellen, welches Entities generiert. So in der Art der konfigurativen Programmierung, RAD-like.
* so Standard-Entitys, wie du die dir vorgestellt hast
-> create default entity User with name:UserCustom
* möglicherweise mit ein paar Parametern:
---> extend with column surname:java.lang.String:100
* und dann noch evtl. völlig neue Entities, für das Projekt
-> create entity with name:XYZ extends Abc implements Uvw
---> extend with column id:java.lang.Long-notNull
---> ....
---> extend with one-to-many ...
....
natürlich so auf Maven-Configuration-Style-XML übersetzt. Ein Maven-Lauf könnte dann den Quellcode der Entities generieren.
Nur mal so gedacht. Nicht gleich mit Dingen nach mir werfen...
Dann hättest du zwar den ganzen Code im Projekt aber kannst ihn ganz leicht anpassen.

 

[internet]

danke dir.
Ich glaube mittlerweile komme ich nicht daran vorbei, dass ich alle Entities direkt im Projekt implementiere, die mindestens eine Referenz von meinem "MyProject" haben...

Prinzipiell kann ich ja die Entity im ShareProject bereits implementieren (Rahmen), in der ich diese dann mit @MappedSuperclass annotiere und dann eben die eigentliche Entity in "MyProject" habe.
Zusätzlich kann ich ja dann die Service Klassen auch im ShareProjekt implementieren - das alles würde mir auch schon mal einiges an doppelten Code sparen...