[JAVA] Modèle de chaîne de responsabilité

Quel est le modèle de la chaîne de responsabilité?

Connectez plusieurs objets comme une chaîne, Comment déterminer l'objet souhaité en parcourant la chaîne d'objets en séquence. Si la demande peut être traitée, elle sera traitée, et si elle ne peut pas être traitée, elle sera traitée. Ensuite, retournez-vous. Le schéma est que le suivant sera à nouveau retourné.

Le rôle de Handler

Un rôle qui définit l'interface de traitement des demandes. Gardez la personne suivante, et si vous recevez une demande que vous ne pouvez pas traiter, envoyez-la à cette personne. La personne suivante joue également le rôle de Handler.

package chainOfResponsibility;

public abstract class Support {
	private String name;
	private Support next;

	public Support(String name) {
		this.name = name;
	}

	public Support setNext(Support next) {
		this.next = next;
		return next;
	}

	public final void support(Trouble trouble) {
		if (resolve(trouble)) {
			done(trouble);
		} else if (next != null) {
			next.support(trouble);
		} else {
			fail(trouble);
		}
	}

	@Override
	public String toString() {
		return "[" + name + "]";
	}

	protected abstract boolean resolve(Trouble trouble);

	protected void done(Trouble trouble) {
		System.out.println(trouble + "is resolved by " + this + ".");
	}

	protected void fail(Trouble trouble) {
		System.out.println(trouble + " cannot be resolved.");
	}
}

Le rôle de ConcreteHandler

Le rôle spécifique du traitement de la demande.

package chainOfResponsibility;

public class NoSupport extends Support{

	public NoSupport(String name) {
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) {
		return false;
	}
}

package chainOfResponsibility;

public class LimitSupport extends Support{
	private int limit;

	public LimitSupport(String name, int limit) {
		super(name);
		this.limit = limit;
	}

	@Override
	protected boolean resolve(Trouble trouble) {
		return trouble.getNumber() < limit;
	}
}

package chainOfResponsibility;

public class SpecialSupport extends Support{
	private int number;

	public SpecialSupport(String name, int number) {
		super(name);
		this.number = number;
	}

	@Override
	protected boolean resolve(Trouble trouble) {
		return trouble.getNumber() == number;
	}

}

package chainOfResponsibility;

public class OddSupport extends Support{

	public OddSupport(String name) {
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) {
		return trouble.getNumber() % 2 == 0;
	}
}

Le rôle du client

Le rôle de faire une demande au premier rôle ConcreteHandler.

package chainOfResponsibility;

public class Main {
	public static void main(String[] args) {
		Support alice = new NoSupport("Alice");
		Support bob = new LimitSupport("Bob", 100);
		Support charlie = new SpecialSupport("Charlie", 429);
		Support diana = new LimitSupport("Diana", 200);
		Support elmo = new OddSupport("Elmo");
		Support fred = new LimitSupport("Fred", 300);
		//Formation de la chaîne
		alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);
		//Divers problèmes surviennent
		for (int i = 0; i < 500; i += 33) {
			alice.support(new Trouble(i));
		}
	}
}

Classe qui représente un problème

package chainOfResponsibility;

public class Trouble {
	private int number;

	 public Trouble(int number) {
		 this.number = number;
	}

	 public int getNumber() {
		 return number;
	 }

	 @Override
	 public String toString() {
		 return "[Trouble " + number + "]";
	 }
}

Résultat d'exécution

https://github.com/aki0207/chainOfResponsibility

Je l'ai utilisé comme référence. Édition révisée augmentée Introduction aux modèles de conception appris en langage Java