# Hibernate OneToMany ManyToOne



## OnDemand (7. Jul 2018)

Hallo zusammen,

eine Frage, ich habe eine Bidirektionale ManyToOne Beziehung:

(Dummycode)


```
class Productst {
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "product")
    private List<ProductsDescription> productsDescription;
//getter + setter
}
```


```
class ProductsDescription{
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "product_id", nullable = false)
    private Product product;
//getter + setter
}
```

Nun wird beim Speichern das Produkt angelegt, aber in der Tabelle productsDescroption wird keine product_id als FK eingetragen (null). 

Muss ich vor dem Speichern jeder ProductsDescription das Product per Setter setzen?

Dachte Hibernate gibt die neu erstellte ID automatisch an die "Childs" weiter oder habe ich da was falsch verstanden. Habe schon sämtliche Varianten aus Stackowerflow versucht, aber immer bleibt der Foreign Key null in der Tabelle productsDescription


----------



## httpdigest (8. Jul 2018)

Zwei Dinge:

1. Damit Hibernate Assoziationen zwischen jeweils zwei Entitäten speichert, muss auf der "owning" Side das Feld gesetzt sein. Die owning-Side ist dabei die Seite, die NICHT das "mappedBy" Annotationsattribut hat. Also bei dir ProductsDescription.product.

2. Damit Hibernate bei einer persist() Operation einer Entität A auch navigierbare assoziierte Entitäten B speichert, muss Hibernate natürlich von A nach B (über ein Feld) kommen können. Wenn du lediglich ein Product speicherst, aber in Product.productDescriptions nicht die ProductDescription hinzufügst, wird Hibernate die ProductDescription nicht persistieren.

Um Punkt 2 zu beheben, also in der Lage zu sein, persists von Produkten zu den Beschreibungen zu cascadieren, musst du die Produktbeschreibung in die Liste am Produkt hinzufügen, bevor du EntityManager.persist(product) aufrufst.

Wie du aber schon festgestellt hast, reicht das nicht, da hier Punkt 1 nicht erfüllt ist, und Hibernate die Assoziation zwischen Produkt und Beschreibung nicht persistert. Es persistiert nur die jeweiligen Entitäten an sich.

Wenn du also sowohl Assoziationen korrekt persistieren möchtest, als auch persist (und andere EntityManager Operationen) korrekt cascadieren möchtest, musst du beide Seiten explizit setzen.


----------



## OnDemand (8. Jul 2018)

Ich bekomm es einfach nicht hin!

ich setze jeder Description in der List das Product und dem Produkt setzte ich die Description List. Es wird einfach nicht gespeichert. Statt dessen kommt jetzt "
org.springframework.web.client.HttpServerErrorException: 500 null" als response, aber der speichernde Service gibt keine Fehlermeldung aus, was da null ist. Langsam verzweifelt ich an diesem Framework.


----------



## mihe7 (8. Jul 2018)

HTTP 500 ist einfach ein allgemeiner Server-Fehler. Dass da "null" steht, hat nicht unbedingt etwas mit der DB zu tun. Gibt es kein Log-File?

Ansonsten:


```
Product p = new Product(); 
ProductsDescription d = new ProductsDescription();
d.setProduct(p);
p.add(d);
save(p);
```


----------



## OnDemand (8. Jul 2018)

Danke so hab ich es. Nur übergebe ich das product an einen restservice. Der output sagt leider nichts daher bin ich so verzweifelt.


----------



## mihe7 (8. Jul 2018)

Kommentiere mal die betreffenden Hibernate-Zeilen im REST-Service aus und schau, was passiert. Wenn das geht, dann mach halt einen try-catch-Block um die Zeilen und log die Exception.


----------



## OnDemand (8. Jul 2018)

Speichern klappt, error kommt von

return new ResponseEntity(product,HttpStatus.CREATED)

Hmm dann scheint der 500 nicht amit dem speichern zutun zu haben...dennoch ist in der tabelle der FK null. Sehr seltsam


----------



## mihe7 (8. Jul 2018)

Wie sieht denn setProduct aus?


----------



## OnDemand (8. Jul 2018)

wie meinst du das?


```
Product product = new Product();
product.setPreis(2.50);
product.setEan("12345");

List<ProductsDescription> descrList = new ArrayList<ProductsDescription>();
ProductsDescription productsDescriptionDe = new ProductsDescription();
        productsDescriptionDe.setProduct(product);
        productsDescriptionDe.setLanguage(new Language("de"));
        productsDescriptionDe.setProductsName("Titel test");

ProductsDescription productsDescriptionEnglisch = new ProductsDescription();
        productsDescriptionEnglisch.setProduct(product);
        productsDescriptionEnglisch.setLanguage(new Language("en"));
        productsDescriptionEnglisch.setProductsName("Title test");

descrList.add(productsDescriptionDe);
descrList.add(productsDescriptionEnglisch);

product.setDescriptions(descList);
```


----------



## mihe7 (8. Jul 2018)

Nein, ich meine ProductsDescription#setProduct.


----------



## OnDemand (8. Jul 2018)

Schau mal, hab noch editiert. 
        productsDescriptionEnglisch.setProduct(product);


----------



## mihe7 (8. Jul 2018)

Die Implementierung von setProduct in der Klasse ProductsDescription will ich sehen


----------



## OnDemand (8. Jul 2018)

Achso  sorry


```
@JsonIgnore
@ManyToOne
@JoinColumn(name = "product_id")
    private Product product;

public Product getProduct() {
        return this.product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }
```


----------



## mihe7 (8. Jul 2018)

Sieht gut aus, wollte nur sichergehen, dass hier kein Tippfehler dafür sorgt, dass this.product unverändert auf null bleibt. Hm... Jetzt muss ich das doch tatsächlich ausprobieren  Dauert einen Moment.


----------



## OnDemand (8. Jul 2018)

Das ist super nett, danke!
Habe nun schon mal den 500 null Fehler ausfindig gemacht :

Funktioniert nicht:

```
ResponseEntity<Product> response = restTemplate.exchange(postUrl, HttpMethod.POST, request,Product.class);
```

Funktioniert:

```
restTemplate.exchange(postUrl, HttpMethod.POST, request,Product.class);
```

Resource:

```
@PostMapping("/persistProduct/{productSku}")
public ResponseEntity<Product> persistProduct(@RequestBody Product newProduct, @PathVariable String productSku) {
        Product currentProd = productsRepository.findByProductsSku(productSku);
        if (currentProd != null) {
            newProduct.setId(currentProd.getId());
            productsRepository.save(newProduct);
>>            return ResponseEntity.status(HttpStatus.OK).body(newProduct);
        } else {
            productsRepository.save(newProduct);
>>           return ResponseEntity.status(HttpStatus.CREATED).body(newProduct);
        }
    }
```
Ist hier beim Speichern vielleicht irgendwas falsch?
Die mit >> markierten Zeilen bringen auch den 500 null


----------



## mihe7 (8. Jul 2018)

Das sind zwei Baustellen. Hier geht es um JPA. 

Da es bei mir länger dauert als gedacht, mal ein Zwischenstand: mit Eclipselink funktioniert es so, wie es soll. 

Bei Hibernate habe ich momentan das Problem, dass ich eine NPE bekomme (dürfte aber einen anderen Grund haben). Bei mir scheint noch irgendeine Konfiguration falsch zu sein.


----------



## OnDemand (8. Jul 2018)

Ok bin gespannt. Werd wegen dem 500 mal einen eigenen thread aufmachen vielleicht ist ja ein (spring) Profi hier der das Problem kennt


----------



## mihe7 (8. Jul 2018)

Also: mit Hibernate 4.3 und 5.2.17 habe ich den gleichen Effekt, unabhängig davon ob man persist oder merge verwendet: die Product-ID wird in ProductsDescription nicht gespeichert.


----------



## mihe7 (8. Jul 2018)

Kommando zurück: mein Fehler, hatte vergessen, das Product zu setzen. Mit 5.2.17: funktioniert, mit 4.3 teste ich gleich noch.


----------



## OnDemand (8. Jul 2018)

Hmmm ok also bin ich doch nicht zu doof. Wenn es in 2 Versionen nicht geht ist es bestimmt kein bug oder ? Finde dazu aber null Info meist ist es das Problem vom fehlenden mappedBy zb.

Daran, dass die Id ein int ist wird es ja nicht sein oder?

Darf das  oneToMany vielleicht nicht sein? Hmm


----------



## OnDemand (8. Jul 2018)

mihe7 hat gesagt.:


> Kommando zurück: mein Fehler, hatte vergessen, das Product zu setzen. Mit 5.2.17: funktioniert, mit 4.3 teste ich gleich noch.



Ok also bin ich doch zu doof ich schau mal welche Version ich nutze


----------



## mihe7 (8. Jul 2018)

Es funktioniert mit Hibernate 4.3.1 und 5.2.17, nicht aber mit 4.3.11, da gibt es einen Fehler: can not set java.lang.Long field Product.id to Product.

Was Deinen Code betrifft: der scheint soweit richtig zu sein.

Welche Hibernate-Version verwendest Du?

EDIT:


NicoDeluxe hat gesagt.:


> Ok also bin ich doch zu doof ich schau mal welche Version ich nutze


OMG. Wer lesen kann, ist klar im Vorteil.


----------



## OnDemand (8. Jul 2018)

5.2.17 hab ich (hat Spring)


----------



## OnDemand (8. Jul 2018)

Haben deine IDs int oder long?


----------



## mihe7 (8. Jul 2018)

Long (nicht long).


----------



## mihe7 (8. Jul 2018)

Hm... Verwendest Du EntityManager oder Hibernate Session?


----------



## OnDemand (8. Jul 2018)

Spring nutz ich und das nutzt glaube  EM unter der Haube, wenn ich das repository von CRudRepository erben lasse. Extends JPARepository geht auch dann dürfte es Session nutzen. Gute Frage eigentlich. EntityManager kann man glaub auch mit @Autowired direkt nutzen. Dazu muss ich mich nochmal genauer belesen


----------



## mihe7 (8. Jul 2018)

Ich frage wegen https://www.mkyong.com/hibernate/cascade-jpa-hibernate-annotation-common-mistake/


----------



## OnDemand (10. Jul 2018)

Hi, sorry für die späte AW.... das geht auch nicht


----------



## mrBrown (10. Jul 2018)

Wie sehen denn jetzt aktuell der Code dazu aus?


----------



## OnDemand (11. Jul 2018)

Hi welchen Code genau magst du sehen? Habe jetzt gemäß obigem Link @Cascade genutzt, aber dennoch bleiben die ID in der Tabelle productsDescription null


```
@OneToMany(mappedBy = "product", fetch = FetchType.LAZY)
@Cascade({ CascadeType.ALL })
private List<ProductsDescription> productsDescription;
```


----------



## OnDemand (11. Jul 2018)

@mihe7 bist du so gut und kannst deinen code der posten? Vielleicht hab ich irgendwas mit den imports verwurstet


----------



## mihe7 (11. Jul 2018)

Klar.


----------



## OnDemand (11. Jul 2018)

Cool danke schau ich mir umgehend an. Mit inno db oder so hat das nix zu tun oder?


----------



## mihe7 (11. Jul 2018)

Nö.


----------



## OnDemand (17. Jul 2018)

Ich bekomm es einfach nicht hin Leute...Ich werd noch wahnsinnig.
Zudem werden auch Relationen nicht korrekt gespeichert wie

Ein Artikel hat einen Großhandel, es wird dann pro Artikel ein eigener Großhandel angelegt obwohl alles der Selbe ist und nur auf diesen verweisen sollte. Ich geb Hibernate auf, welche Alternativen habe ich? Scheinbar bin ich zu dämlich dafür


----------



## mrBrown (17. Jul 2018)

Wie sieht denn der Code aus? Eigentlich ist das alles kein Hexenwerk...

Leichter ist vermutlich nur, gänzlich ohne ORM und stattdessen direkt mit SQL zu arbeiten..


Dein letztes Problem klingt danach, als weißt du ihnen auch explizit unterschiedliche Großhandel zu, da wäre Code wieder interessant...



Spoiler



Für die Produkte mit Unidirektionaler Beziehung (Bidirektional braucht man in dem Fall höchstens für Optimierungen):


```
import java.util.*;
import javax.persistence.*;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Long id;

    @OneToMany(cascade = CascadeType.ALL)
    private List<ProductsDescription> productsDescriptions;

    public void addProductsDescription(ProductsDescription productsDescription) {
        if (this.productsDescriptions == null) {
            this.productsDescriptions = new ArrayList<>();
        }
        this.productsDescriptions.add(productsDescription);
    }

    public List<ProductsDescription> getProductsDescriptions() {
        return productsDescriptions;
    }

}
```


```
import javax.persistence.*;

@Entity
public class ProductsDescription {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Long id;

    @Column
    private String text;

    ProductsDescription() {
    }

    public ProductsDescription(final String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

}
```


```
import org.springframework.data.repository.CrudRepository;

public interface ProductRepository extends CrudRepository<Product, Long> {

}
```


```
Product newProduct = new Product();
        newProduct.addProductsDescription(new ProductsDescription("Beschreibung..."));
        productRepository.save(newProduct);

        Product product = productRepository.findById(1L).get();
        assertThat(product.getProductsDescriptions().get(0).getText()).isEqualTo("Beschreibung...");
```


----------



## OnDemand (18. Jul 2018)

Wie in deinem Spoiler klappt es, dann wird aber eine zusätzliche Tabelle angelegt, was die Sache langsamer macht oder? Also fühlt sich langsamer an.


----------



## OnDemand (18. Jul 2018)

Bezgl. der Beschreibung, kann es sein, dass ich zu erst das Product speichern muss, dann die ID holen und an die Productbeschreibung setzen?

Verstehe nicht warum das nicht so wir in den ganzen tutorials klappt.


----------



## mihe7 (18. Jul 2018)

Wenn das Beispiel von @mrBrown funktioniert, dann muss das Produkt offensichtlich nicht gespeichert werden. In meinem Beispiel muss man das auch nicht. Aber: erweitere den Code einfach so lange, bis es nicht mehr funktioniert. Dann weißt Du, wo es hakt.


----------



## mrBrown (18. Jul 2018)

NicoDeluxe hat gesagt.:


> Wie in deinem Spoiler klappt es, dann wird aber eine zusätzliche Tabelle angelegt, was die Sache langsamer macht oder? Also fühlt sich langsamer an.


Wenn das dadurch bei weniger als Tausenden Produkten spürbar langsamer arbeitet, würde ich dir raten, das ganze mal auf nem Computer und nicht auf nem Taschenrechner von '93 laufen zu lassen 

Aber ja, das erfordert einen zusätzliche Tabelle und einen Join. Kann man durch entsprechende Annotation lösen, macht's dann aber komplizierter.



NicoDeluxe hat gesagt.:


> Bezgl. der Beschreibung, kann es sein, dass ich zu erst das Product speichern muss, dann die ID holen und an die Productbeschreibung setzen?


Nö, eben das ist mit cascade nicht nötig.



NicoDeluxe hat gesagt.:


> Verstehe nicht warum das nicht so wir in den ganzen tutorials klappt.


Keine Ahnung, aber wie gesagt, mit etwas Code könnte man vllt was sagen


----------



## thecain (19. Jul 2018)

Ohne zusätzliche hints macht Hibernate meines Wissens kein Join sondern n selects, was durchaus ein Performance killer sein kann


----------



## mihe7 (19. Jul 2018)

@thecain das dürfte zwar stimmen, jedoch unabhängig von der Join-Table gelten. OneToMany/ManyToMany sind in JPA lazy by default - egal, ob mit oder ohne Join-Table (WIMRE).


----------



## OnDemand (19. Jul 2018)

Hier mal mein aktueller Stand, wie es funktioniert, aber null als product_id in description gespeichert wird. Seh mittlerweile den Wald vor lauter Bäumen nicht mehr

ProductCreator.java - Liest die Rohdaten und erstellt je ein Product und sendet es an einen Rest Service siehe unten zum speichern

```
String postUrl = "http://....";
Product myProduct = new Product();
List<ProductsDescription> descrList = new ArrayList<ProductsDescription>();

ProductsDescription productsDescription = new ProductsDescription();
productsDescription.setName("Testname");
productsDescription.setLongDescription("lange Beschreibung...");

descrList.add(productsDescription);

productsDescription.setProduct(myProduct);
myProduct.setProductsDescriptions(descrList);

ResponseEntity<Product> product = restTemplate.exchange(postUrl, HttpMethod.POST, request, Product.class);
```

Controller.java - anderer Service der das Product entgegen nehmen soll und es speichert

```
@PostMapping("/persistProduct/{productSku}")
public ResponseEntity<Product> persistProduct(@RequestBody Product myProduct, @PathVariable String productSku) {
Product currentProd = productsRepository.findByProductsSku(productSku);
if (currentProd != null) {     
myProduct.setId(currentProd.getId());
productsRepository.save(myProduct);
return ResponseEntity.status(HttpStatus.OK).body(myProduct);
        } else {
            productsRepository.save(myProduct);
            return ResponseEntity.status(HttpStatus.CREATED).body(myProduct);
        }
    }
```

Product.java


```
@Id
@GeneratedValue
@Column(name = "id")
private Integer id;

//CascadeType.ALL brings auch nicht
@OneToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH }, mappedBy = "product")
private List<ProductsDescription> productsDescriptions = new ArrayList<>();
//Getter und Setter
```

ProductDescription.java

```
@Id
@GeneratedValue
@Column(name = "id")
private Integer id;

//Auch hier versucht CascadeType.ALL versucht
@ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH })
private Product product;

//Getter und Setter
```


----------



## mrBrown (19. Jul 2018)

Das das ganze vor dem Speichern zu Json serialisiert und wieder deserialisiert wird ist eine nicht so unwesentliche Information, die bisher irgendwie fehlte...

Rein ins Blaue geraten kommt auf Server-Seite nicht das an, was du erwartest. Hast du das mal mit'm Debugger überprüft?




NicoDeluxe hat gesagt.:


> ProductCreator.java


`request` wird dort benutzt, aber nirgends deklariert.



NicoDeluxe hat gesagt.:


> ```
> descrList.add(productsDescription);
> 
> productsDescription.setProduct(myProduct);
> ...


Sowas sollte immer Grund sein, das Model anzupassen.
Es gibt wenig Gründe dafür, dass da mehr als ein (beispielhaftes) `myProduct.addProductsDescriptions(productsDescription)` steht, und viele dagegen.


----------



## OnDemand (20. Jul 2018)

Moin,

bezgl. request hab ich nur vergessen zu kopieren:

```
RestTemplate restTemplate = new RestTemplate();
 HttpEntity<Product> request = new HttpEntity<>(myProduct);
```

Bezgl. der addMethode hatte ich ebenfalls, werd ich mir nochmal überlegen die zu nutzen, wenn das Speichern klappt. Vorteil ist, fremde Schnittstellennutzer können einzelne Beschreibungen adden und nich eine ganze List.

In der Speichermethode kommt eigentlich an, was ich erwarte (außer die id ist null, klar). Denn in der Tabelle product_description werden alle Werte gespeichert, bis auf die product_id zum product. Im product selbst steht auch alles wie erwartet.

Was ich komisch finde, dass die productsDescriptions Product enthalten, welche auch wiederum eine List an ProductDescriptions haben. Ich vermute hier irgendwo den Fehler, dass ich da irgendwas falsch setze


----------



## mrBrown (20. Jul 2018)

NicoDeluxe hat gesagt.:


> Bezgl. der addMethode hatte ich ebenfalls, werd ich mir nochmal überlegen die zu nutzen, wenn das Speichern klappt. Vorteil ist, fremde Schnittstellennutzer können einzelne Beschreibungen adden und nich eine ganze List.


Vor allem vermeidet es einen Haufen Fehler^^



NicoDeluxe hat gesagt.:


> In der Speichermethode kommt eigentlich an, was ich erwarte (außer die id ist null, klar). Denn in der Tabelle product_description werden alle Werte gespeichert, bis auf die product_id zum product. Im product selbst steht auch alles wie erwartet.
> 
> Was ich komisch finde, dass die productsDescriptions Product enthalten, welche auch wiederum eine List an ProductDescriptions haben. Ich vermute hier irgendwo den Fehler, dass ich da irgendwas falsch setze


Hast du mit nem Debugger (oder passend getricksten souts) geprüft, ob die sich auch wirklich gegenseitig referenzieren?

Das klingt nicht danach, als wären die zirkulären Referenzen passend deserialisiert worden (die meisten Mapper bekommen das auch afaik gar nicht ohne weiteres hin).


----------



## OnDemand (20. Jul 2018)

Ja hab ich im debugger geprüft. Die Beschreibungen stimmen auch, die geadded werden. Nur eben wird die ID nicht eingetragen die beim speichern des products vergeben werden. 
Echt kurios


----------



## OnDemand (20. Jul 2018)

Hahaa es ist doch kein Product gesetzt siehe Bild, obwohl ich es setze.

productsDescription.setProduct(myProduct);


----------



## mrBrown (20. Jul 2018)

Du setzt es vor der Serialisierung, das heißt nicht, dass es nach der Deserialisierung immer noch gesetzt ist.

Mach es Unidirektional, Bidirektional wirst du dabei nicht brauchen, und das macht es dir erheblich einfacher  Wenn dich die Join-Table stört, nutz `@JoinColumn`


----------



## OnDemand (20. Jul 2018)

Ach, das könnte die Ursache sein? implements Serializeable hilft da nicht? Das hab ich nämlich nicht.

Das Product wird der Description schon beim "Versender" nicht gesetzt, noch vor dem serialisieren.


----------



## mrBrown (20. Jul 2018)

NicoDeluxe hat gesagt.:


> Ach, das könnte die Ursache sein? implements Serializeable hilft da nicht? Das hab ich nämlich nicht.


Nein, du serialisiert vermutlich zu JSON? Das kennt erstmal sowieso keine zirkulären Referenzen, je nach Mapper lassen die sich nur mit Vorarbeit deinerseits verarbeiten.
Wie schon mehrmals gesagt: verzichte auf Zyklen, die machen nur Probleme.



NicoDeluxe hat gesagt.:


> Das Product wird der Description schon beim "Versender" nicht gesetzt, noch vor dem serialisieren.


Dann ist wohl dein Setter falsch.



Verzichte einfach erstmal auf das ganze drum herum und schreib 'nen Integration-Test, in dem du nur das Speichern testest. Das wird dir wesentlich weniger Arbeit machen...


----------



## OnDemand (20. Jul 2018)

Ich find der sieht korrekt aus:
in ProductsDescription.java

```
public void setProduct(Product product) {
        this.product = product;
}
```

Ja genau, zu Json. Ok wenn ich es Unidirektional mache, wäre es dann wie folgt korrekt?


```
@OneToMany(cascade=CascadeType.ALL)
@JoinColumn(name="product_id")
private List<ProductsDescription> productsDescriptions = new ArrayList<>();
```

In der Productsdescripton entferne ich dann das product?


----------



## mrBrown (20. Jul 2018)

NicoDeluxe hat gesagt.:


> Ich find der sieht korrekt aus:
> in ProductsDescription.java
> 
> ```
> ...


Na so viele Möglichkeiten gibt es nicht, dass nach einem korrektem Aufruf davon der Wert trotzdem noch null ist...





NicoDeluxe hat gesagt.:


> Ok wenn ich es Unidirektional mache, wäre es dann wie folgt korrekt?
> 
> 
> ```
> ...


Ja, sollte passen. Probier's einfach aus


----------



## OnDemand (20. Jul 2018)

Es klaaaapt Juhuuuuu   Danke Dir!!

Jetzt aber mal zum Verständnis:
Unidirektional; ich komme von Product auf die dazughehörige Beschreibung und andersherum auch. Was ist dann bidirektional?


----------



## mrBrown (20. Jul 2018)

NicoDeluxe hat gesagt.:


> Jetzt aber mal zum Verständnis:
> Unidirektional; ich komme von Product auf die dazughehörige Beschreibung und andersherum auch. Was ist dann bidirektional?


Wie kommst du von Beschreibung zu Produkt?

Unidirektional: Die eine Klasse referenziert die andere, es gibt aber keine Referenz zurück: 
Product --> ProductsDescription

Bidirektional: Beide Klassen verweisen aufeinander: 
Produkt <--> ProductsDescription


----------



## OnDemand (21. Jul 2018)

Vielen Dank  

Da das speichern jetzt funktioniert, und ich beim Updaten einer Beschreibung entscheiden möchte, ob der Name aktualisiert wird oder nicht, wie kann ich das angehen? Muss ich da mit Transaktionen arbeiten oder kann ich bestimmte Spalten vom Update ausschließen? (Ist aber abhängig, manchmal sollen sie updated werden, weil ein User das will, ein anderer will es nicht) muss also dynamisch im Code irgendwie gehen


----------



## mrBrown (21. Jul 2018)

NicoDeluxe hat gesagt.:


> Da das speichern jetzt funktioniert, und ich beim Updaten einer Beschreibung entscheiden möchte, ob der Name aktualisiert wird oder nicht, wie kann ich das angehen?


Änder einfach den Namen der Beschreibung und Speicher dann das Produkt 


NicoDeluxe hat gesagt.:


> Muss ich da mit Transaktionen arbeiten


Das ist generell sinnvoll, du solltest dir Transaktionen nur sinnvoll platzieren.



NicoDeluxe hat gesagt.:


> oder kann ich bestimmte Spalten vom Update ausschließen?


Warum solltest du Spalten vom Update ausschließen?

Sieh das Repository nicht als SQL-Abstraktion, sondern einfach nur als Collection von Objekten. Du übergibst dem einfach ein Objekt, und dieses wird im aktuellem Zustand im Repo abgelegt.


----------



## OnDemand (21. Jul 2018)

Es möchten einige User zum Beispiel nicht, dass der Name aktualisiert wird, da sie einen eigenen Namen vergeben und dieser in der DB nicht überschrieben werden sollen. Daher muss ich beim speichern wie folgt vorgehen, so in der Art:

user.isUpdateName(){
//alles updaten;
} else{
//name nicht updaten
//aber Beschreibung 
}

Der ursprüngliche Name kommt vom Hersteller, der Benutzer kann diesen in der App zb ändern. Wenn dann die Artikeldaten vom Hersteller aktualisiert wurden, dürfen diese, die manuell geänderten Namen nicht überschreiben


----------



## mrBrown (21. Jul 2018)

Und wovon hängt ab, ob es geupdated werden darf?
Ist das eine Einstellung, die der Nutzer tätig oder bestimmt sich das z.B. daraus, ob der Nutzer den Namen schon mal angepasst hat?


Mit dem Speichern hat das in beiden Fällen nichts zu tun - das ist eine Anforderung der Domäne und sollte damit auch in dieser behandelt werden.


Das ganze wirkt etwa so, als wird das versucht, etwas technisch umzusetzen, obwohl das ganze kaum modelliert wurde?
An dieser Stelle des Designprozesses hat JPA (für mich) noch nichts zu suchen, das kann man höchstens im Kopf behalten, dass es irgendwann in Zukunft mal umgesetzt werden soll.


----------



## OnDemand (21. Jul 2018)

Ja das stellt der Nutzer in der Oberfläche ein genau, also meinst das sollte schon beim erstellen des product beachtet werden? Stimmt, nicht schlecht könnte klappen


----------



## mrBrown (22. Jul 2018)

NicoDeluxe hat gesagt.:


> Ja das stellt der Nutzer in der Oberfläche ein genau


Und ein Produkt gehört also immer genau einem Nutzer?



NicoDeluxe hat gesagt.:


> also meinst das sollte schon beim erstellen des product beachtet werden? Stimmt, nicht schlecht könnte klappen


Je nachdem, was du mit Erstellen meinst.
Dass ganze sollte beim modellieren der Domänenklasse berücksichtigt werden, bevor die Java-Klasse erstellt wird.
"Erstellen" meint da nicht irgendein `new` im Code


----------

