[JAVA] DTO/Entity come ritornare/gestire i sottoggetti ?

[FabryHw]

Stavo implementando un layer di accesso alla base dati usando dei DTO (anche se sarebbero più degli Entity Beans) con relative classi DAO che usano JDBC (JPA/Hibernate scartati dopo mesi di litigi e grosse difficoltà ad adattarli a DB esistenti) e mi sono venuti dei dubbi (scarsa esperienza sulla cosa) su come gestire il passaggio degli oggetti non primitivi.

Facciamo un esempio con una classe DTO che contiene 2 oggetti non primitivi:

public class MyDTO implements Serializable {
@NotNull
private Key1 pKey = new Key1();

private String description;

@NotNull
private String attribute1;

@Min(value=0)
private int quantity;

@NotNull
private Key categoryFKey = new Key2();

public MyDTO () {
}

...
}
con le altre classi così definite:

public class Key1 implements Serializable {
@Min(value=1)
private int id;

@NotNull @Size(min=1, max=2)
private String type;

public Key1 () {
}

public Key1 (int id, String type) {
this.id= id;
this.type = type;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id= id;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

@Override
public int hashCode() {
...
}

@Override
public boolean equals(Object object) {
...
}

@Override
public String toString() {
...
}
}

public class Key2 implements Serializable {

@NotNull @Size(min=1, max=4)
private String category;

@NotNull @Size(min=1, max=2)
private String subCategory;

public Key2 () {
}

public Key2 (String category, String subCategory) {
this.category= category;
this.subCategory= subCategory;
}

public String getCategory() {
return category;
}

public void setCategory(String category) {
this.category= category;
}

public String getSubCategory() {
return subCategory;
}

public void setSubCategory(String subCategory) {
this.subCategory= subCategory;
}

@Override
public int hashCode() {
...
}

@Override
public boolean equals(Object object) {
...
}

@Override
public String toString() {
...
}
}

Ora il mio dubbio è come devono essere i getter/setter di MyDTO quando hanno a che fare con gli oggetti non primitivi.
Ossia ritornare una copia del riferimento all'oggetto contenuto o clonare questo oggetto e ritornare il riferimento alla copia.

Codice Soluzione 1:

public Key1 getPK() {
return pKey;
}

public void setPK(Key1 pKey) {
this.pKey= pKey;
}

public Key2 getCategoryFKey() {
return categoryFKey;
}

public void setCategoryFKey(Key2 fKey) {
this.categoryFKey = fKey;
}

Codice Soluzione 2:


public Key1 getPK() {
Key1 clone = new Key1();
clone.setId(pKey.getId());
clone.setType(pKey.getType());
return clone;
//Oppure in modo meno prolisso un
// return new Key1(pKey.getId(), pKey.getType());
}

public void setPK(Key1 pKey) {
this.pKey.setId(pKey.getId());
this.pKey.setType(pKey.getType());
}

public Key2 getCategoryFKey() {
return new Key2(categoryFKey.getCategory(), categoryFKey.getSubCategory();
}

public void setCategoryFKey(Key2 fKey) {
this.categoryFKey.setCategory(fKey.getCategory());
this.categoryFKey.setSubCategory(fKey.getSubCategory());
}


Con la prima soluzione i vantaggi sono:

Codice più semplice per i getter e setter (spesso autogenerato dall'IDE)
Possibilità di condividere alcuni oggetti interni tra più oggetti
Non vengono creati oggetti a vita brevissima (necessari solo per passare i parametri)
Se cambio le definizioni di Key1 o Key2 automaticamente MyDTO è aggiornato senza dover modificare il suo codice

ma gli svantaggi sono:

Espongo lo stato interno dell'oggetto a modifiche indirette
Rischio che modifiche a nuovi oggetti indirettamente (e probabilmente erroneamente) cambino anche altri oggetti già esistenti.
Esempio

MyDTO obj1 = new MyDTO();
....
Key2 cat = obj1.getCatogoryFKey();
MyDTO obj2 = new MyDTO();
...
obj2.setCategoryFKey(cat);
...
obj2.getCategoryFKey().setCategory("0200");
obj2.getCategoryFKey().setSubCategory("IT");
ecco le ultime 2 righe volevano assegnare una nuova categoria a obj2 ma indirettamente l'hanno cambiata anche a obj1
Più facile cadere in memory leaks causa riferimenti incrociati e/o condivisi tra vari oggetti

La soluzione 2 ha come vantaggi:

Lo stato interno di ogni oggetto è modificabile solo attraverso i setter e modifiche agli oggetti esportati non cambiano lo stato interno di chi li ha esportati.
Più difficile che avvegano memory leaks

ma per contro presenta come svantaggi:

Getter e Setter più complicati da scrivere
Se cambiano Key1 e Key2 bisogna rivedere tutti i getter e setter di MyDTO coinvolti a meno di trovare una soluzione generica per il cloning.
Vengono creati tanti oggetti a vita brevissima per passare i parametri o restituire il risultato.
Maggiore lavoro per il garbage collector e maggior uso di cpu nel creare i duplicati.
Maggior uso di memoria perché non si condivide nulla (anche quando si poteva farlo in sicurezza) ed ogni oggetto interno è duplicato


Quindi qual'è l'approccio migliore ?
C'è una terza possibilità ?