javablog.ch» Codestyle

Effective Java: Builder-Pattern

HeikoMaass — Sat, 23 Aug 2008 12:45:01 +0000

7 Jahre nach der ersten Auflage ist das Buch “Effective Java” von Joshua Bloch nun endlich in der zweiten Auflage erschienen. Der Klassiker wurde komplett runderneuert: Best-Practises für ‘neue’ Sprachelemente wie Generics und Enums kamen hinzu, veraltete Kapitel (wie der Ersatz von C-Strukturen) wurden gestrichen.

Neu ist auch das “Builder-Pattern”. Es kommt zum Einsatz, wenn ein Objekt viele optionale Variablen besitzt. Die bisherige, klassische Variante bei solchen Objekten ist das Schreiben von mehreren Konstruktoren (‘telescoping constructor’), die über unterschiedliche Anzahl von Parametern verfügen. Allerdings sinkt die Lesbarkeit bei mehr als 6 Parametern gewaltig (vor allem wenn die Parameter vom gleichen Typ sind).

Das “Builder-Pattern” verzichtet auf die ‘telescoping constructors’ und arbeitet stattdessen mit einer statischen inneren Klasse, die für das Erzeugen einer Instanz der äusseren Klasse zuständig ist. Der Konstruktor des Builder-Objekts enthält alle “Pflicht”-Variablen, die optionalen Variablen werden über (verkettbare) Methodenaufrufe hinzugefügt. Abschliessend wird die build Methode aufgerufen, die ein unveränderliches Objekt der äusseren Klasse erzeugt. Der Konstruktor der äusseren Klasse ist privat, d.h. nur ein Builder kann ein Objekt tatsächlich instanzieren:

Hier ein Beispiel:

package ch.javablog.builderpattern;
 
import java.math.BigDecimal;
 
public class Product {
        // all fields are final: immutable object
        private final String id;
        private final BigDecimal price;
        private final String salesDescription;
        private final Product baseProduct;
        private final boolean approved;
 
        private Product (Builder builder) {
                // private Constructor can only be called from Builder
                this.id = builder.id;
                this.price = builder.price;
                this.salesDescription = builder.salesDescription;
                this.baseProduct = builder.baseProduct;
                this.approved = builder.approved;
        }
 
        public String getId() {
                return id;
        }
 
        public BigDecimal getPrice() {
                return price;
        }
 
        public String getSalesDescription() {
                return salesDescription;
        }
 
        public Product getBaseProduct() {
                return baseProduct;
        }
 
        public boolean isApproved() {
                return approved;
        }
 
        public static class Builder {
                // mandatory parameter
                private final String id;
                private final BigDecimal price;
 
                // optional
                private String salesDescription = "";
                private Product baseProduct     = null;
                private boolean approved        = true;
 
                public Builder(String id, BigDecimal price) {
                        this.id = id;
                        this.price = price;
                }
                public Builder salesDescription(String salesDescription) {
                        this.salesDescription = salesDescription;
                        return this;
                }
                public Builder baseProduct(Product baseProduct) {
                        this.baseProduct = baseProduct;
                        return this;
                }
                public Builder approved(boolean approved) {
                        this.approved = approved;
                        return this;
                }
 
                public Product build() {
                        return new Product(this);
                }
        }
}
 
public class ProductClient {
        public static void main(String... args) {
                BigDecimal price = BigDecimal.valueOf(36.5);
                Product.Builder builder = new Product.Builder("050-0047",price);
                // create Product using the builder
                Product p = builder
                                .salesDescription("great product")
                                .approved(false)
                                .build();
        }
}

OVal – the object validation framework for Java 5 or later

HeikoMaass — Mon, 17 Mar 2008 22:43:02 +0000

Ich muss gestehen, ich bin ein Fan von defensiver Programmierung, d.h. ich deklariere mögliche Inkonsistenzen von Objekten durch das Werfen von RuntimeExceptions (z.B. IllegalStateException oder IllegalArgumentException). Praktisch finde ich ebenfalls das Prinzip der Unveränderlichkeit. Einmal erzeugt, soll das Objekt nicht mehr verändert werden. Somit werden Inkonsistenzen (z.B. nicht gesetzte Attribute) bereits im Vorfeld vermieden.

Allerdings verursacht diese Form der Absicherung unschönen Code-Overhead, da jeder Parameter manuell überprüft werden muss. Zudem stehen unveränderliche Objekte im Widerspruch mit der JavaBean Spezifikation

Vor kurzem habe ich einen interessanten Lösungsansatz im OVal Framework entdeckt. Hier werden die Properties und Methoden mit Annotations versehen und explizit oder implizit (via AspectJ) validiert. Beispiele gibts heute keine, stattdessen verweise ich auf die (gute) Doku.

Buchtipp: Effektiv Java programmieren

HeikoMaass — Sun, 30 Jul 2006 15:18:00 +0000

“Effektiv Java programmieren” (ISBN 3-8273-1933-1) von Joshua Bloch gehört eindeutig zur Pflichtlektüre jedes professionellen Javaprogrammieres. In 57 kurz gehaltenen Kapiteln werden Regeln und Tipps für einen robusten und sauberen Programmierstil definiert. Als kleinen Appetitanreger fasse ich zwei seiner Regeln zusammen.

Thema 9: Überschreiben Sie toString immer.

Die toString Methode von java.lang.Object gibt standardmässig den Klassennamen und den Hashcode des Objects zurück. Für Debuggingzwecke ist diese Information nicht besonders aussagekräftig, von daher sollte jede Klasse diese Methode überschreiben und in ihr sämtliche relevanten Inhalte des Objekts zurückgeben.

Beispiel: toString Methode aus SquareTile (Klasse zur Speicherung einer quadratischen Bildkachel in einer Kartenanwendung). Hier gibt die toString Methode die Koordinate der linken oberen Kante und die Breite zurück. Das ist beim Debugging (bzw. beim Logfile-Lesen) wesentlich hilfreicher als der Hashcode.

public String toString() {
        return  "topLeftCoord: " + topLeftCoord.toString() + '\\t' +
                "width == height: " + width;
    }

Thema 13: Bevorzugen Sie Unveränderbarkeit

Unveränderliche Klassen erlauben lediglich bei der Konstruktion des Objekts das Setzen von Werten. Im Nachhinein können keine Werte mehr gesetzt werden (Es gibt also keine Setter-Methoden). Zudem sind alle Felder als final und private deklariert.

Vorteil: Die Anzahl möglicher Zustände reduziert sich dramatisch, da das Objekt nach dem Konstruktor fertig initialisiert ist. Es gibt also keine unfertigen Objektstati, die man bei Methodenaufrufen überprüfen muss. Zudem sind solche Klassen automatisch Thread-sicher.
Die Javabibliothek verwendet viele unveränderliche Klassen, z.B. java.lang.String oder java.math.BigInteger .

Nachteil: Für jeden Wert muss ein eigenes Objekt erzeugt werden. Bei vielen und grossen Objekten kann dies recht kostspielig werden (bekanntester Effekt: Stringverkettung). Benötigt eine unveränderliche Klasse zudem viele Initialisierungsparameter, so leidet darunter die Lesbarkeit des Konstruktors, da hier alle Parameter übergeben werden müssen.