Controllare le precondizioni nel modo corretto

Ho una classe con circa 1300 linee e ha molti metodi simili a CRUD che necessitano di parametri da controllare, per alcuni è più di poche regole.

Per motivi di chiarezza, userò nomi generici per la mia classe e i miei metodi.

Ho finito di implementare tutte le precondizioni di recente, e sebbene lo abbia fatto in modo caustico con if block all'inizio dei metodi e procedure simili, ho finito per avere una specie di chunks ripetuti (che ho provato ad estrarre in metodi privati, ma questo non ha aiutato completamente) e una classe che va bene, ma essendo in ordine e chiaro come sono, voglio davvero ristrutturarlo.

Quindi questa è una versione molto succinta della mia classe, quindi hai l'idea di come appare:

public class Event {
    public void setAttribute1(List<Attribute1> attribute1) {
        if (attribute1 == null)
            throw new IllegalArgumentException("Attribute1 cannot be null");

        if (attribute1.isEmpty())
            throw new IllegalArgumentException("Attribute1 cannot be empty");

        // check for repeated elements

        // check for more things

        this.attribute1 = attribute1;
    }

    public void addAttribute1(Attribute1 attr) {
        // null check

        // check not existing

        // check for more things

        attribute1.add(attr);
    }

    public void removeAttribute1(Attribute1 attr) {
        // null check

        // check not existing

        attribute1.remove(attr);
    }

    public void setMyMap(Map<K, V> myMap) {
        // null check

        // keys check

        // values check

        // more and more

        this.myMap = myMap;
    }

    // a long etc...
}

Finisco con enormi pezzi, talvolta parzialmente ripetuti, di controlli di precondizione. Questo è disordinato e confuso. Soprattutto quando ho molti metodi simili per lo stesso attributo, dove ho gli stessi controlli, tranne che non sono la stessa cosa. Nel caso in cui l'esempio sopra non aiuti a capire cosa intendo, questo sarebbe un caso che si ripete molto nella mia classe:

public class Event {
    private List<K> kDomain;
    private List<V> vDomain;
    private int kConfig;

    public void setMap(Map<K, Set<V>> map) {
        // null check

        // all k in K should be in kDomain

        // the length of the map should match an arithmetical operation based on the value of kConfig
        // (and similar checks)

        // a null Set<V> associated to a K should be illegal

        // for each k, each v in V should be in vDomain
    }

    public void addVtoK(K k, V v) {
        // null check k and v

        // k must be in kDomain

        // v must be in vDomain

        // if k has already a set of Vs, v must not be in that set already (already existing object check)
    }

    public void addVsToK(K k, Set<V> vs) {
        // null check k and vs

        // k must be in kDomain

        // all v in vs should be in vDomain

        // no v in vs can already be associated to k
    }
}

Come puoi vedere, ho controlli lunghi che sembrano molto simili, ma non sono uguali.

Sto cercando di trovare i modi migliori per ristrutturare la mia intera classe, che sono abbastanza sicuro che finirò per riscrivere.

Ho esaminato Condizioni di Guava e sembra netti, ma anche se sarebbe un miglioramento del codice, ci sono alcune precondizioni da controllare che sono un po 'più complesse da elaborare e richiedono un pensiero progettuale più profondo.

Quale sarebbe l'approccio corretto? O sto pensando troppo al mio problema?