Mut zur Fachlichkeit

@mobileLarson  
@_openKnowledge
Lars Röwekamp
CIO New Technologies
Mut zur Fachlichkeit
#WISSENTEILEN

Business vs. Technology
Java

Land
„May I submit my billing info to your
merchant account via your payment
gateway?“
oﬀenkundiggut #WISSENTEILEN

Java

Land

End User
Domain

Expert
Technical

Expert
Translation
ist auf Dauer teuer
- sogar sehr teuer!
Java

Land

Java

Land
End User
Domain

Expert
Technical

Expert
Ubiquitous Language
Basis für ein  
konsistentes
Domain Model

„Produce Software  
that makes perfectly  
sense to business,  
not only to coder“
Java

Land
End User
Domain

Expert
Technical

Expert
Rich Domain Model

„Produce Software  
that is always  
in a correct state,  
not only partially“
Java

Land
Domain

Expert
Technical

Expert
Rich Domain Model
Access Layer
Business Layer
DB Layer

Reality CheckJava 
Land
The déjà-vu

Experiment

/**
* Represents a business customer with a
* full qualified name, a date of birth indicating
* if the customer is „sui juris“ and a valid address
* that may change after a relocation.
*/
public class Customer {
private String firstName;
private String sureName;
private Date birthDate;
private Address address;
public void setFirstName(String aFirstName) { ... }
public String getFirstName() { return firstName; }
public void setSureName(String aSureName) { ... }
public String getSureName() { return sureName; }
public void setBirthDate(Date birthDate) { ... }
public Date getBirthDate() { return birthDate; }
public void setAddress(Address address) { ... }
public Address getAddress() { return address; }
}
Reality Check
Fachlichkeit?
Java 
Land Mut zur Fachlichkeit

/**
*/
public Customer(String firstName,
String sureName,
String zipCode,
String city) { ... }
String sureName,
String zipCode,
String city,
String street) { ... }
...
}
Reality Check
Parameter (Hölle)?
Java 
Konstruktor (Hölle)?

/**
*/
String sureName,
String zipCode,
String city) {
Validate.isTrue(StringUtils.isNotEmpty(firstName));
Validate.isTrue(StringUtils.isNotEmpty(sureName));
...
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
...
}
Validierung?

/**
*/
private static final String ZCODE_PATTERN = ...;
String sureName,
String zipCode,
String city) {
setFirstName(firstName);
setZipCode(zipCode);
...
}
public void setZipCode(String zipCode) {
Validate.isTrue(Pattern.matches(ZCODE_PATTERN, zipCode));
}
...
}
Richtig hier?

/**
* Represents a controller to handle
* customer related changes
*/
public class CustomerController {
/**
* save new date of birth retrieved from the web
* in a customer entity
*/
public void alterBirthDate(Customer customer, String newDate) {
SimpleDateFormat df = new SimpleDateFormat();
Date birthDate = null;
try {
birthDate = df.parse(newDate);
} catch (ParseException e) {
// do something
}
Date today = new Date();
if (birthDate.after(today)) {
// do something
} else {
customer.setBirthDate(birthDate);
}
} ...
}
Konvertierung?

/**
* Represents a controller to handle
* customer related changes
*/
public class CustomerController {
/**
* check if a customer has birthday today
*/
public boolean hasBirthDay(Customer customer) {
Calendar todayCal = Calendar.getInstance();
Calendar birthDateCal = Calendar.getInstance();
birthDate.setTime(customer.getBirthDate().getTime());
if (birthDateCal.get(Calendar.YEAR) > (todayCal.get(Calendar.YEAR))) {
return false;
} else if (birthDateCal.get(Calendar.MONTH) !=
todayCal.get(Calendar.MONTH) ) {
return false;
} else if (birthDateCal.get(Calendar.DAY_OF_MONTH) != (todayCal
.get(Calendar.DAY_OF_MONTH))) {
return false;
}
return true;
}
...
}
Auswertung?

/**
* Util to calculate current age for a given date
* and to calculate if the date is a birthday today.
*/
public class BirthDayUtilAkaHelper {
public static boolean hasBirthDay(Date date) {
...
return ...;
}
public static int getAge(Date date) {
return 0;
}
}
/**
* usage of BirthdayUtil
*/
Customer customer = ...;
if (BirthDayUtilAkaHelper.hasBirthDay(customer.getBirthDate())) {
...;
}
Util & Helper (Hölle)?
a.k.a. Manager

/**
*/
public void setBirthDate(Date newBirthDate) {
if (isInFuture(newBirthDate)) { /*abort */ ... }
birthDate = newBirthDate;
}
public Date getBirthDate() {
return birthDate;
}
...
}
/**
* usage of getBirthDate
*/
Customer customer = ...;
customer.getBirthDate().setTime(someTimeInFuture);
Reality Check
Immutable?
Java 

/**
* Data Access Object for retrieving
* customer objects from the DB.
*/
public class CustomerDao {
public List<Customer> findByZipCodeOrCity(String zipCode, String city) {
return ...;
}
public List<Customer> findByZipCodeOrCityWithLimit(String zipCode,
String city, int limit) {
return ...;
}
public List<Customer> findByZipCodeOrCityAndOrders(String zipCode,
String city, int orderCount) {
return ...;
}
}
/**
* usage of getBirthDate
*/
String current= ...;
String value = ...;
List<Customer> searchResult = dao.findByZipCodeOrCity(current,value);
Reality Check
Meaningful API?
Java 
Correct Order?

/**
* Data Access Object for retrieving
* customer objects from the DB.
*/
public class CustomerDao {
// BEFORE refactoring
public List<Customer> findByZipCodeOrCity(String zipCode,
String city) {
return ...;
}
// AFTER refactoring
public List<Customer> findByZipCodeOrCity(String zipCode,
String city,  
String street) {
return ...;
}
...;
}
Reality Check
Refactoring?
Java 

ProblemfelderJava 
Land

Java 
Problemfelder
Resultat des „Reality Check“
‣ Anemic Domain Model
‣ wenig aussagekräftige APIs
‣ fehlendes Null-Value Handling
‣ inkonsequente oder fehlende Validierung
‣ duplizierter Code
‣ Util, Helper & Manager Hölle
Fehlende
Robustheit!

Problemfelder
Fehlende Robustheit
‣ Teamwachstum / -ﬂuktuation als Risiko
‣ Wo ﬁnde ich was?
‣ Was macht das?
‣ Wo gehört das hin?
‣ Copy & Paste Design Pattern!
Java 
Land

LösungsansätzeJava 
Land

Zur Erinnerung
„Wir möchten ein sprechendes Domain Model,
mit einem sprechenden API, welches wir in sich
konsistent erzeugen und im weiteren Verlauf
konsequent konsistent erhalten.“
LösungsansätzeJava 
Land

Lösungsansätze
Rich Domain Model
‣ inkl. Fachlichkeit
‣ inkl. Validierung
‣ inkl. Konvertierung
‣ inkl. Normalisierung
‣ inkl. Konsistenzprüfung
Java 
Land

Lösungsansätze
Refactoring Step by Step
‣ Rich Entities
‣ Value Objects
‣ Builder Pattern (Bonusmaterial)
Java 
Land

Java 
Rich Entities

Rich Entities
„An object that is not
deﬁned by its
attributes, but rather
by a thread of
continuity and its
identity.“
Java 

Rich Entity Charakteristika (1/2)
‣ Kontinuität über einen Zeitraum
‣ Existenz einer eindeutigen Identität, mit
(fachlichem) Schlüssel, z.B. User-Name
‣ Änderung der Attribute ändern die Identität
nicht, d.h. Identität bleibt konstant
Rich EntitiesJava 
Land

Rich Entity Charakteristika (2/2)
‣ Entitäten mit gleichen Attributen sind nicht
zwingend gleich
‣ Entitäten mit verschiedenen Attributen können
dennoch identisch sein
‣ Vorsicht bei Operationen, die Entitäten über
Attribute vergleichen
Land

„Golden Rules“ für Entitäten …
‣ #1: sind in sich konsistent
‣ #2: setter nur für fachlich änderbare Attribute
‣ #3: enthalten ihre Fachlichkeit
‣ #4: sind fachliche Objekte
Land

/**
* #1: Entitäten sind in sich konsistent
*
*/
private String lastName;
private Customer(String name) {
lastName = notNull(name);
};
...
)
commons.lang3.Validate
Java 
Rich Entities

BTW: Validation
Java 
Rich Entities
/**
* #2: Nur fachlich änderbare Attribute haben Setter
*
*/
public Customer(String name) {
lastName = setLastname(name);
};
public void setLastName(String name) {
lastName = notNull(name);
};
...
)

Java 
Rich Entities
/**
* #3: Entitäten enthalten ihre Fachlichkeit. d.h.
* Attributänderungen sind fachliche Operationen
*/
public class Customer extends Person {
private boolean married;
private Person partner;
public void setLastName(String name) { … };
public void setMarried(boolean married) { … };
public void setPartner(Partner partner) { … };
…
)

Java 
Rich Entities
/**
* #3: Entitäten enthalten ihre Fachlichkeit. d.h.
* Attributänderungen sind fachliche Operationen
*/
private FamilyStatus familyStatus;
private Person partner;
public void marry(Person aPartner, String aLastName) {
lastName = notNull(aLastName)
familyStatus = FamilyStatus.MARRIED;
partner = ...; //guarantee bidirectional consistency!
};
…
)

/**
* #4: Entities sind fachliche Objekte.Eigenschaften
* repräsentieren Fachlichkeit und sind nur in
* Ausnahmefällen „Primitive.
*/
…
)
Land

/**
* #4: Entities sind fachliche Objekte.Eigenschaften
* repräsentieren Fachlichkeit und sind nur in
* Ausnahmefällen „Primitive.
*/
private LastName lastName;
…
)
Rich Entities
Was ist das, bitte?
Java 
Land

Value ObjectsJava 
Land

„An object that contains
attributes but has  
no conceptual identity.
They should be treated
as immutable.“
Java 
Value Objects

Value Objects Charakteristika (1/2)
‣ Keine konzeptionelle Identität
‣ Beschreibung von Charakteristika
‣ „was“ statt „wer“?
‣ Gleichheit via Gleichheit der Attribute deﬁniert
‣ Unveränderlich
‣ Daten sind zu jedem Zeitpunkt konsistent
Land

Value Objects Charakteristika (2/2)
‣ Operationen auf Value Objects
‣ In sich abgeschlossen
‣ Rückgabe-Wert ist eine neue Instanz mit
geändertem Wert
‣ Beispiele aus Java
‣ java.lang.String, java.math.BigInteger, …
Land

Value Objects …
‣ #1: sind Objekte und keine Primitive
‣ #2: sind unveränderbar
‣ #3: konvertieren fachlich
‣ #4: normalisieren fachlich
‣ #5: validieren fachlich
‣ #6: sind vollwertig und vergleichbar
Java 
Land
Value Objects

/**
* #1: Value Objects sind Objekte
*/
...
)
Land

/**
* #1: Value Objects sind Objekte
*/
private DateOfBirth birthDate;
...
)
Land

/**
* Represents a date of birth
*/
public class DateOfBirth {
private Date dateOfBirth;
public boolean isBirthDayToday() {
return ...;
}
public int getCurrentAge() {
return ...;
}
}
Land

/**
* #2: Value Objects sind unveränderbar
*/
public DateOfBirth(Date date) { ... }
public Date getDate() {
return new Date(dateOfBirth.getTime());
}
}
Immutable!
Land

/**
* #3: Value Objects konvertieren fachlich
*/
public DateOfBirth(Date date) { ... }
public DateOfBirth(String date) { ... }
public DateOfBirth(String date,
String pattern) { ... }
...
}
Konvertieren!
Land

/**
* #4: Value Objects normalisieren fachlich
*/
public DateOfBirth(Date date) {
...;
this.dateOfBirth = copyAndStripTimeStamp(date);
}
...
}
Normalisieren!
Land

/**
* #5: Value Objects validieren fachlich
*/
public DateOfBirth(Date date) {
Date today = new Date();
if (date.after(today)) {
throw new IllegalArgumentException( 
"Birthday " + date
+ " may not be after current time " + today);
} ...
} ...
}
Validieren!
Land

/**
* #6: Value Objects sind vollwertig
*/
public class DateOfBirth implements Serializable, Comparable{
...
@Override
public String toString() {
return ...;
}
@Override
public int hashCode() {
return ...;
}
@Override
public boolean equals(Object obj) {
return ...;
}
public int compareTo(Object o) {
return ...;
}
}
Full blown Object!
Land

Value Objects Beispiele
‣ FirstName, LastName, DateOfBirth
‣ ZipCode, City, Country
‣ Email, PhoneNumber
‣ Note, Description
‣ Year, Month, …
‣ Money, …
Java 
Land
Value Objects

Value Objects, wo sind da die Grenzen
‣ Ein Value Object repräsentiert eine fachlich
relevante Eigenschaft des Domain Models.
Land

Rich Domain Model Beneﬁts
‣ Fachlichkeit beﬁndet sich direkt in der Domain
‣ Kein/kaum duplizierter Code
‣ sprechender & konsistenter Code
‣ verbesserter Lesbarkeit & Wartbarkeit
‣ Keine Util, Helper, Manager & Friends
Java 
Land
Putting together

// Entity with Value Objects
private FirstName firstName;
private LastName lastName;
private FamilyStatus familyStatus;
private Address postalAddress;
private Map<PhoneNumberType, PhoneNumber> phoneNumbers;
private Map<EmailType, Email> emailAddresses;
...
public void marry(LastName newLastName) {
lastName = newLastName
familyStatus = FamilyStatus.MARRIED;
}
public boolean isMarried() {
return (familyStatus == FamilyStatus.MARRIED);
}
}
Putting togetherJava 
Land

// Entity with Value Objects
...
private Map<PhoneNumberType, PhoneNumber> phoneNumbers;
...
public void changeHomePhoneNumber(
PhoneNumber changedHomePhoneNumber) { ... }
public void disconnectHomePhone() { ...}
public void changeMobilePhoneNumber(
PhoneNumber changedHomePhoneNumber) { ... }
public void disconnectMobilePhone() { ... }
...
}
Putting togetherJava 
Land

Builder PatternJava 
Land

Das kleine 1x1 des Builder Pattern
‣ Object Creation Design Pattern
‣ Antwort auf das Constructor-Hell Anti-Pattern
‣ Step-by-Step Ansatz
‣ Kandidat für Fluent-API
Java 
Land
Builder Pattern

// Builder Pattern - Poor Mans Edition
public class Address {
public Address(String street,
String streetNumber,
String zipCode,
String city,
String state,
String country) {
Validate.isTrue(StringUtils.isNotEmpty(streetNumber));
Validate.isTrue(StringUtils.isNotEmpty(zipCode));
Validate.isTrue(StringUtils.isNotEmpty(city));
Validate.isTrue(StringUtils.isNotEmpty(state));
Validate.isTrue(StringUtils.isNotEmpty(country));
...
}
// value object is immutable
// - no setter
// - but getter
...;
}
Schön? Nee!
Java 
Land
Builder Pattern

// Builder Pattern - Simple Edition IN ACTION
// create AddressBuilder
AddressBuilder builder = new AddressBuilder();
// set all known values
// BTW: could be also used in JSF and other frameworks
builder.setStreet(...);
builder.setStreetNumber(...);
builder.setZipCode(...);
builder.setCity(...);
builder.setState(...);
builder.setCountry(...);
// build valid and immutable Address object
Address address = builder.build();
Schöner?
Java 
Land
Builder Pattern

// Builder Pattern - Simple Edition
public class AddressBuilder {
private Street street;
private StreetNumber streetNumber;
private ZipCode zipCode;
private City city;
private State state;
private Country country;
public Address build() {
// validate single parameter and cross parameter constraints
// and throw exception if any problem occurs
...
// create valid Address object else
return new Address(...);
}
public void setStreet(Street street) {
this.street = street;
}
public void setStreetNumber(StreetNumber streetNumber) {
this.streetNumber = streetNumber;
}
...
}
Naja!
Java 
Land
Builder Pattern

// Builder Pattern - Extended Edition IN ACTION
// create AddressBuilder
Address address = Address.newAddress()
// set values
.forStreetNumber(...).ofStreet(...)
.inCity(...).withZipCode(...)
.lyingInState(...).ofCountry(...)
// build Address object
.build(...);
Schöner?
Java 
Land
Builder Pattern

// Builder Pattern - Extended Edition with Inner Class Builder
public class Address {
public static Builder newAddress() {
return new Address().new Builder();
}
private String street;
public class Builder {
public Builder ofStreet(String initialStreet) {
street = validateStreet(initialStreet);
return this;
}
public Address build() {
validate();
return Address.this;
}
}
}
Ja!
Java 
Land
Builder Pattern

FazitJava 
Land
The Design is the Code,
the Code is the Design.

„Muss ich denn jedes Mal
den Code ändern,
wenn sich die
Fachlichkeit ändert?“
FazitJava 
Land

„Zur Hölle, ja!
Wann denn  
bitte sonst?“
FazitJava 
Land

Bildnachweise
Java 
Land
‣ #1: iStock.com/Andrew Rich (36508576)
‣ #2: iStock.com/shironosov (46494512)
‣ #19: iStock.com/Peshkova (26981250)
‣ #22: iStock.com/Andrew Rich (35766696)
‣ #50: iStock.com/mcsilvey (1604024)
‣ #57: iStock.com/pinestock (44615094)
‣ #7: © vasakna - Fotolia.com
‣ #28, #41: pixabay.com

Mut zur Fachlichkeit

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie Mut zur Fachlichkeit

Ähnlich wie Mut zur Fachlichkeit (20)

Mehr von OPEN KNOWLEDGE GmbH

Mehr von OPEN KNOWLEDGE GmbH (20)

Mut zur Fachlichkeit