Un Reqeust Builder

package corso.java.mypersonalblog.helpers;

import java.util.ArrayList;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

/**
 * Questa classe si occuperà di costruire la stringa di request
 * a partire da tutti i pezzi che la compongono.
 */
public class RequestBuilder {
    // Una URL è costituita da tante parti:
    // authority://host:port/path_1/.../path_n?p1=v1&...&pn=vn
    // URL Google: https://www.google.com:80/search?q=testocercato
    /**
     * Memorizza l'authority della URL.
     */
    private String authority;
    /**
     * Memorizza l'host al quale collegarci.
     */
    private String host;

    /**
     * Legge il valore del campo authority.
     */
    public String getAuthority() {
        return authority;
    }

    // Template builder serve per un NOTAZIONE FLUENTE:
    // RequestBuilder builder = new RequestBuilder().setAuthority("http").setHost("192.168.1.1").setPort(8080)

    /**
     * Imposta il campo authority.
     *
     * @param authority il valore del campo authority.
     */
    public RequestBuilder setAuthority(String authority) {
        this.authority = authority;
        return this;
    }

    /**
     * Legge il valore del campo host.
     */
    public String getHost() {
        return host;
    }

    /**
     * Imposta l'host.
     *
     * @param host il valore dell'host.
     */
    public RequestBuilder setHost(String host) {
        this.host = host;
        return this;
    }

    /**
     * Legge la porta sull'host.
     */
    public int getPort() {
        return port;
    }

    /**
     * Imposta la porta sull'host.
     *
     * @param port il valore della porta dell'host.
     */
    public RequestBuilder setPort(int port) {
        this.port = port;
        return this;
    }

    /**
     * Memorizza la porta sull'host.
     */
    private int port;
    /**
     * Memorizza i pezzi del path.
     */
    private List<String> paths;

    // concedo la possibilità di aggiungere e togliere parti del path
    // RequestBuilder builder = new RequestBuilder().setAuthority("http").setHost("192.168.1.1").setPort(8080)
    //                          .addPath(0, "path1").addPath("path2").remove(1).remove("path1")

    /**
     * Aggiunge un percorso.
     *
     * @param position posizione nella quale aggiungere il percorso.
     * @param path     percorso da aggiungere.
     */
    public RequestBuilder addPath(int position, String path) {
        paths.add(position, path);
        return this;
    }

    /**
     * Overloading del metodo precendente.
     * Determina un'altra possibilità nell'invocazione del metodo: a differenza del metodo
     * precedente che aggiungeva in una determinata posizione, questo aggiunge alla fine.
     *
     * @param path percorso da aggiungere.
     */
    public RequestBuilder addPath(String path) {
        paths.add(path);
        return this;
    }

    /**
     * Rimuove il percorso che si trova in una particolare posizione.
     *
     * @param position la posizione del percorso da rimuovere.
     */
    public RequestBuilder removePath(int position) {
        paths.remove(position);
        return this;
    }

    /**
     * Rimuove il path passato come parametro.
     *
     * @param pathToRemove il path da rimuovere.
     */
    public RequestBuilder removePath(String pathToRemove) {
        paths.remove(pathToRemove);
        return this;
    }

    /**
     * Memorizza i pezzi della query string.
     */
    private Dictionary<String, String> queryString;
    // accesso alle parti di query string

    /**
     * Aggiunge una parte di query string.
     *
     * @param key   parametro di query.
     * @param value valore associato al parametro.
     */
    public RequestBuilder addQuery(String key, String value) {
        queryString.put(key, value);
        return this;
    }

    /**
     * Rimuove una parte di query string.
     *
     * @param key parametro da rimuovere.
     */
    public RequestBuilder removeQuery(String key) {
        queryString.remove(key);
        return this;
    }

    // Costanti della classe
    /**
     * Definizione della costante che rappresenta un'authority di tipo http con traffico in chiaro.
     */
    public static final String AUTHORITY_HTTP = "http";
    /**
     * Definizione della costante che rappresenta un'autority di tipo http con traffico crittografato.
     */
    public static final String AUTHORITY_HTTPS = "https";

    /**
     * Il costruttore deve preoccuparsi di inizializzare gli elementi interni alla classe.
     */
    public RequestBuilder() {
        authority = AUTHORITY_HTTPS; // per default la classe costruisce una request predisposta per https
        host = "10.0.0.2"; // questo potrebbe essere un host di default, utilizzato se non provvedo a modificarlo
        port = 80; // questa è la porta di default di un web server, verso cui vanno tutte le richieste HTTP
        paths = new ArrayList<>(); // path è una List inizializzata come ArrayList
        queryString = new Hashtable<>();
    }

    /**
     * Produce la request come stringa.
     *
     * @return restituisce la request costruita sulla base dei valori degli attributi della classe.
     */
    public String build() {
        // devo costruire questo:
        // authority://host:port/path_1/.../path_n?p1=v1&...&pn=vn
        StringBuilder sb = new StringBuilder() // costruisco una stringa per passaggi successivi
                .append(authority) // aggiungo l'authority
                .append("://") // aggiungo questi tre caratteri
                .append(host); // aggiungo l'host
        if (port != 80)  // se la porta non è quella standard...
            sb.append(":").append(port); // aggiungo la porta dopo i due punti
        sb.append("/"); // aggiungo una slash
        for (String path : paths) // scorro i paths
            sb.append(path).append("/"); // e li aggiungo uno ad uno
        // controllo se ci sono query strings
        if (queryString.size() > 0) {
            // il dizionario implementa Enumeration sulle chiavi
            Enumeration<String> e = queryString.keys();
            while (e.hasMoreElements()) // scorro le chiavi
            {
                // leggo la chiave corrente
                String key = e.nextElement();
                // leggo il valore associato
                String value = queryString.get(key);
                // lo aggiungo alla stringa e aggiungo pure una & alla fine per la concatenazione
                sb.append(key).append("=").append(value).append("&");
            }
        }
        // alla fine restituisco la query string
        return sb.toString();
    }
}