责任链(Chain of Responsibility)模式

1. **降低耦合度** 该模式使得一个对象无需知道是其他哪一个对象的其请求。对象仅需知道该请求会被“正确”地处理。接受者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。

2. **增强了给对象指派责任(Responsibility)的灵活性** 当在对象中分配职责时，职责链给你更多的灵活性，你可以通过在运行时刻对该链进行动态的增加或者修改来增加或者改变处理一个请求的那些职责。你可以将这种机制与静态的特例化处理对象的继承机制结合起来使用。

1. **不保证被接受** 既然一个请求没有明确的接受者，那么就不能保证它一定会被处理——该请求可能一直在链对的末端都得不到处理。一个请求也可能因该链没有被正确配置而得不到处理。

1. **实现后继者链** 有两种方法可以实现后继者链。

2. **连接后继者** 如果没有已有的 _引用_ 可定义一个链，那么你必须自己引入它们。这种情况下Handler不仅定义该请求的接口，通常也维护后继链接(可以通过构造器实现)。这样Handler就提供了handleRequest的缺省实现：handleRequest向后继者(如果有的话)转发请求。如果ConcreteHandler子类对该请求不感兴趣，它不需要重定义转发操作，因为它的缺省实现时无条件转发。

    public class Test {

    	
    	public Pack handle(Pack pack) {
    		// ...... handle process
    		pack.doSomething();
    		return pack;
    	}
    }

    public interface Pack {

    	void doSomething();
    }

    public class DIYPack implements Pack{

    
    	@Override
    	public void doSomething() {
    		
    	}
    }

    public class Email {
    	private String author;
    	private EmailType type;
    	private String content;
    	private LocalDate date;
    	
    	public Email(String author, 
    			EmailType type, 
    			String content, 
    			LocalDate date ) {
    		this.author = author;
    		this.type = type;
    		this.content = content;
    		this.date = date;
    	}
    	
    	public String getAuthor() {
    		return author;
    	}
    	public void setAuthor(String author) {
    		this.author = author;
    	}
    	public EmailType getType() {
    		return type;
    	}
    	public void setType(EmailType type) {
    		this.type = type;
    	}
    	public String getContent() {
    		return content;
    	}
    	public void setContent(String content) {
    		this.content = content;
    	}
    	public LocalDate getDate() {
    		return date;
    	}
    	public void setDate(LocalDate date) {
    		this.date = date;
    	}
    	
    }

    public interface Handler {
    	
    	void  nextHandler(Handler handler);
    	
    	void  handleEmail(Email email);
    	
    }

    public enum EmailType {
    	FANS_EMAIL,COMPLAIN_EMAIL,ADVICE_EMAIL,RUBBISH_EMAIL;
    	// has an implicit empty constructor. Let's be explicit instead,
    	// 枚举有一个其实也是类 自带空的默认构造器
    }

    public class AdviceEmailHandler implements Handler {
    	
    	private Handler nextHandler;
    	private BusinessDepartment businessDepartment;
    	
    	public AdviceEmailHandler() {
    		businessDepartment  = new BusinessDepartment();
    	}
    	
    	@Override
    	public void nextHandler(Handler nextHandler) {
    		this.nextHandler = nextHandler;
    	}
    	
    	@Override
    	public void handleEmail(Email email) {
    		if (email != null) {
    			if (email.getType() == EmailType.ADVICE_EMAIL) {
    				businessDepartment.readEmail(email);
    			} 
    			else this.nextHandler.handleEmail(email);
    		}
    	}
    }

    public class BusinessDepartment {
    	public void readEmail(Email email) {
    		System.out.println("Business department read the email : " + 
    				email.getContent());
    	}
    }

    public class ComplainEmailHandler implements Handler {
    	
    	private Handler nextHandler;
    	private LawDepartment lawDepartment;
    	
    	public ComplainEmailHandler() {
    		lawDepartment = new LawDepartment();
    	}
    	
    	@Override
    	public void nextHandler(Handler nextHandler) {
    		this.nextHandler = nextHandler;
    	}
    	
    	
    	@Override
    	public void handleEmail(Email email) {
    		if (email != null) {
    			if (email.getType() == EmailType.COMPLAIN_EMAIL) {
    				lawDepartment.readEmail(email);
    			}
    			else this.nextHandler.handleEmail(email);
    		}
    	}
    }

    public class LawDepartment {
    	
    	public void readEmail(Email email) {
    		System.out.println("Law department read the Email :" + 
    				email.getContent());
    	}
    }

    public class FanEmailHandler implements Handler{
    	
    	private Handler nextHandler;
    	private CEO ceo;
    	
    	public FanEmailHandler() {
    		ceo = new CEO();
    	}
    	
    	@Override
    	public void nextHandler(Handler nextHandler) {
    		this.nextHandler = nextHandler;
    	}
    	
    	@Override
    	public void handleEmail(Email email) {
    		if (email != null) {
    			if (email.getType() == EmailType.FANS_EMAIL) {
    				ceo.readEmail(email);
    			}
    			else this.nextHandler.handleEmail(email);
    		}
    	}
    }

    public class CEO {
    	
    	public  void readEmail(Email email) {
    		System.out.println("CEO read email : " + email.getContent());
    	}
    }

    public class RubbishEmailHandler implements Handler {
    	
    	private Handler nextHandler;
    
    	
    	@Override
    	public void nextHandler(Handler nextHandler) {
    		this.nextHandler = nextHandler;
    	}
    	
    	@Override
    	public void handleEmail(Email email) {
    		if (email != null) {
    			if (email.getType() == EmailType.RUBBISH_EMAIL) {
    				ReStation.INSTANCE.recycleEmail(email);
    			}
    			else this.nextHandler.handleEmail(email);
    		}		
    	}	
    }

    public enum ReStation {
    	INSTANCE;  // INSTANCE is same as 
    			   //  public static final MySingleton INSTANCE = new MySingleton(); 
    			   // 但更加简洁且无偿提供了序列化机制，即使在面对复杂的序列化或者反射攻击的时候
    			   // 都能防止多次实例化。
    		 
    	private List<Email> emailList ;
    	
    	private ReStation() {
    		emailList = new ArrayList<>();
    	}
    	
    	public synchronized void recycleEmail(Email email) {
    		System.out.println("Recycle station recycleing the email: " 
    				+ email.getContent());
    		emailList.add(email);
    	}
    	
    	public synchronized void deleteEmail(Email email) {
    		emailList.remove(email);
    	}
    	
    	public synchronized void clear() {
    		emailList.clear();
    	}
    }

    public class NonHandler implements Handler {
    	
    	@Override
    	public void nextHandler(Handler nextHandler) {
    		
    	}
    	
    	@Override
    	public void handleEmail(Email email) {
    		
    	}	
    }

    public class EmailListTestDrive {	
    	
    	private Handler handler1;
    	
    	private List<Email> emailList;
    	
    	public EmailListTestDrive(List<Email> emailList) {
    		this.emailList = emailList;
    		handler1 = new FanEmailHandler();
    		Handler handler2 = new ComplainEmailHandler();
    		Handler handler3 = new AdviceEmailHandler();
    		Handler handler4 = new RubbishEmailHandler();
    		Handler nonHandler = new NonHandler();
    		handler1.nextHandler(handler2);
    		handler2.nextHandler(handler3);
    		handler3.nextHandler(handler4);
    		handler4.nextHandler(nonHandler);
    	}
    	
    	public void handleEmailList() {
    		for (Email email : emailList) {
    			handler1.handleEmail(email);
    		}
    	}
    	
    	
    	
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		List<Email> emailList = new ArrayList<>();
    		Email email1 = new Email("yanxun", EmailType.FANS_EMAIL, 
    				"哇，这是我第一次使用自己的责任链模式",  LocalDate.now());
    		Email email2 = new Email("wanzilin", EmailType.COMPLAIN_EMAIL, 
    				"哇，我王者荣耀10颗星", LocalDate.of(2019, 3, 8));
    		Email email3 = new Email("kobe", EmailType.ADVICE_EMAIL, 
    				"Ok,your gumball is too sweet", LocalDate.of(2018, 8, 24));
    		Email email4 = new Email("ルフィ", EmailType.RUBBISH_EMAIL, 
    				"私はワンピースになりたい人です。", LocalDate.of(2017, 5, 1));
    		
    		emailList.add(email4);
    		emailList.add(email3);
    		emailList.add(email2);
    		emailList.add(email1);
    		EmailListTestDrive testDrive = new EmailListTestDrive(emailList);
    		testDrive.handleEmailList();
    	}
    
    }

    Recycle station recycleing the email: 私はワンピースになりたい人です。
    Business department read the email : Ok,your gumball is too sweet
    Law department read the Email :哇，我王者荣耀10颗星
    CEO read email : 哇，这是我第一次使用自己的责任链模式