Quali modelli di progettazione utilizzerei per questo algoritmo?

Sembra abbastanza semplice per me che non hai davvero bisogno di un modello di design, per dire. Hai 6 passaggi, ognuno dei quali richiede solo una singola riga di esecuzione (eccetto la Linea 4, poiché potrebbe essere un hash complesso).

Chain of Command è più un metodo fire-and-forget tra oggetti distinti. Non è proprio il caso qui. E Builder utilizza più un singolo percorso di esecuzione per eseguire la stessa azione su più tipi di oggetti. Ancora una volta, nel tuo caso, è un percorso unico e coerente, quindi non penserei che sarebbe adatto neanche a

La classe che fa tutto questo sarebbe un Factory con una funzione generate() .

Quando l'algoritmo di hashing e la codifica dei caratteri devono essere scambiabili, devi farlo implementando queste strategie .

Queste strategie potrebbero essere passate al costruttore della fabbrica, potresti avere diverse sottoclassi di fabbriche che usano diversi gruppi di strategie ( Modello di fabbrica astratto ), potresti passare le strategie a ogni chiamata della funzione di generazione oppure puoi impostare le strategie da utilizzare per tutte le chiamate successive attraverso i setter della fabbrica ( Pattern di costruzione ). Quale di queste opzioni usare (o forse un mix di esse) è una questione di gusti.

I am asking about design patterns to adapt for a change in requirements.

Non pensare ai modelli di progettazione per adattarsi ai cambiamenti dei requisiti

Utilizza modelli di progettazione per semplificare il codice che hai scritto per soddisfare i requisiti noti. Il tentativo di prevedere i requisiti futuri è solo leggermente più semplice rispetto alla previsione dei prezzi delle azioni.

Questo sembra un tipico caso d'uso per un modello di metodo del modello ; avere una classe che ha 7 metodi, 6 per ogni passo corrispondente e un metodo che richiama tutti gli altri 6 metodi in ordine. I metodi che possono cambiare li rendono astratti e vengono implementati per loro in sottoclassi; per esempio crea sottoclassi per UTF-8 e per altre codifiche; lo stesso per altri metodi che possono molto. In modo semplificato:

public abstract class StringProcessor {
    public void perform() {
        generateGuid();
        generateEncoding();
        //...
    }

    protected void generateGuid() {
        //logic
    }

    protected abstract void generateEncoding();
}

public class Utf8EncodingStringProcessor extends StringProcessor {
    protected generateEncoding() {
         //UTF-8 logic
    }
}

public class OtherEncodingStringProcessor extends StringProcessor {
    protected generateEncoding() {
         //Other logic
    }
}

Questo non sarebbe così utile se hai bisogno di UTF-8 con algoritmo hashing 1, UTF-8 con algoritmo hasing 2, altra codifica con algoritmo hashing 1, altra codifica con algoritmo hash 2 ecc. Se ti serve molta flessibilità I consigliamo di utilizzare il modello di metodo del modello combinato con schema di strategia per ogni metodo che può variare. Potrebbe sembrare qualcosa di semplificato:

public abstract class StringProcessor {
    private Encoding encoding;   
    private Hashing hashing;

    public StringProcessor(EncodingType encodingType, HashingType hashingType) {
         if (UTF8.equals(encodingType)) {
              encoding = new Utf8Encoding();
         } else if( ....)
    }

    public void perform() {
        generateGuid();
        encoding.encode();
        hashing.generateHash();
        //...
    }

    public void generateGuid() {
        //logic
    }    
}

public enum EncodingType {
    UTF8, OTHER, //...
}

public interface Encoding {
    void encode();
}    

public class Utf8Encoding implements Encoding {
    public void encode() {
         //UTF-8 logic
    }
}

Generatore e catena di responsabilità non sembrano funzionare poiché il builder ti consente di creare solo un oggetto parziale, ma devi chiamare tutti i metodi; anche la catena di responsabilità non è utile dal momento che devi sempre delegare la parte superiore della gerarchia e raggiungere sempre la parte superiore del comando per chiamare tutti i metodi.