디자인패턴 _ (14)chain of Responsibility

책임 떠넘기기

어떤 사람에게 요구하고, 처리할 수 있으면 처리하고, 처리할 수 없으면 요구를 다른 사람에게 넘긴다.

떠넘기기=자신의 일에 집중하기

class종류

📌Trouble : 발생한 트러블을 나타내는 클래스. 트러블 번호를 가진다
📌Support : 트러블을 해결하는 추상 클래스
📌NoSupport : 트러블을 해결하는 구상 클래스 (항상 '처리하지 않는다')
📌LimitSupport : 트러블을 해결하는 구상 클래스 (지정한 번호 미만의 트러블을 해결)
📌OddSupport : 트러블을 해결하는 구상 클래스 (홀수 번호의 트러블을 해결 )
📌SpecialSupport : 트러블을 해결하는 구상 클래스 (특정 번호의 트러블을 해결 )
📌Main : Support들의 사슬을 만들고 트러블을 발생시키는 동작 테스트용 클래스

Trouble class

• number: 트러블 번호
• getNumber : 메소드에서 트러블 번호를 얻는다.

public class Trouble{
	private int number; //트러블 번호
    public Trouble (int number) {this.number = number ;}//트러블의 생성 
    
    public int getNumber(){ return number; } //트러블 번호를 얻는다. 
    public String toString(){ //트러블 문자열 표현 
    	return "[trouble"+ number +"]" ; 
    }
}

Support class (부모 클래스)

• 문제를 해결할 사슬을 만들기 위한 추상 클래스.
• next 필드는 떠 넘기는 곳을 지정
• setNext 메소드는 떠 넘기는 곳을 설정
• resolve 메소드는 하위클래스에서 구현할 곳을 상정한 추상 메소드
• resolve 메소드의 반환값 true:요구 처리 됨 // flase:요구 처리 안됨 -> '다음 사람에게 떠넘기기 '

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 touble){  //트러블 해결 수순 
    	if(resolve(trouble)){
        	done(trouble);  //해결 
        }else if(next != null){
        	next.support(trouble);
        }else {
        	fail(trouble);  //미해결 
        }
    }
    
    
    public String toString(){     //문자열 표현 
    	return "[" +name + "]"; 
    }
    
    
  🚨protected abstract boolean resolve(Trouble trouble); //(구체적 클래스)자식들이 구체적으로 구현 
    protected void done (Trouble trouble){  //해결 
    	System.out.println(trouble+"is resolved by" +this.toString +"."); 
    }
    
    
    
 protected void fail(Trouble trouble){   //미해결 
 	System.out.println(trouble+"cannot be resolved.");
    }       
}

자식클래스

📌 NoSupport class

• Support의 하위 클래스
• resolve 메소드는 항상 false를 반환
• 즉 아무것도 처리하지 않는 클래스

public class NoSupport extends Support{
	public NoSupport(String name){
    	super(name);   
    } 
    protected boolean resolve(Trouble trouble){ //해결 메소드 
    	return false;   //항상 false 반환 
    } 
}

📌 LimitSupport class

• limit에서 지정한 번호 미만의 트러블을 해결

public class LimitSupport extends Support{
	private int limit;   // 이 번호 미만이면 해결 가능 
    public LimitSupport (String name, int limit){
    	super(name);
        this.limit=limit;
    }
    
  🚨protected boolean resolve(Trouble touble){
    	if( trouble.getNumber()<limit){
        	return true; 
       } else{
            retrun false;
         }
    }
}

📌 OddSupport class

• 홀수 번호의 트러블을 처리하는 클래스

public class OddSupport extends Support{
	public OddSupport(String name){
    	super (name);
    }
    
  🚨protected boolean resolve(Trouble trouble){
    if(trouble.getNumber()%2==1){
    	return true;
    }else {
    	return false;
   	}
  }    
}

📌 SpecialSupport class

• 지정한 번호의 트러블에 한하여 처리하는 클래스

public class SpecialSupport extends Support{
	private int number; // number; 이 번호만 해결가능
    public SpecialSupport(String name, int number){
    	super(name);
        this.number=number; 
    }
  🚨protected boolean resolve(Trouble trouble){
    
    	if (trouble.getName()==number;{
        	return true; 
            } else {
            	return false;
            }            
        }
}

📌 Main class

public class Main{
	public static void main(String[] args){
    	Support alice = new NoSupport("Alilce");
        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);
        
//사슬의 형성 
alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);

//트러블의 발생 
for(int i=0; i<500; i+=33){
	alice.support(new Trouble(i);
	}                   
 }
}