JAVA中的责任链模式（CH02）

对责任链CH01做出优化，解决耦合度太高问题

记得上一篇我们使用的是抽象类，然后用子类去继承的方法实现等级的桥接，从而发现了耦合度太高。

　　为了解决这个问题。

　　我们本次使用接口进行抽象，然后使用到一个”中介“对所要申请的经费进行自动判断。

　　这个类似于web的过滤器。让我们来Look一Look吧！

一，首先我们创建一个接口，抽象出审批费用的方法

public interface AbstractHandler {
    //抽象审批经费的方法，这里有两个参数
    //第一个参数是：申请经费
    //第二个参数是：处理链接的类，也就是中介
    void execute(int money,HandlerChain chain);

}

二，创建三个等级，分别实现AbstractHandler接口

a) money<=200

public class HandlerA implements AbstractHandler {
    @Override
    public void execute(int money,HandlerChain chain) {
        if(money<=200){//对经费进行判断
            System.out.println("A审核通过…………");
        }else{
            //如果审批权限不够，则去上一级领导申请，
            chain.doFilter(money);
        }
    }
}

b)money<=500

public class HandlerB implements AbstractHandler {
    @Override
    public void execute(int money,HandlerChain chain) {
        if(money<=500){
            System.out.println("B审核可以通过…………");
        }else{
　　　　　　　　
            chain.doFilter(money);
        }
    }
}

c)money<=1000

public class HandlerC implements AbstractHandler {
    @Override
    public void execute(int money,HandlerChain chain) {
        if(money<=1000){
            System.out.println("C审核通过…………");
        }else{
            chain.doFilter(money);
        }
    }
}

三，最主要的是这个分配中介，也就是链接处理

public class HandlerChain {

    //用来存放所有Handler实例 泛型是抽象接口
    private List<AbstractHandler> list= new ArrayList<AbstractHandler>();

    //定义一个迭代器，用来迭代list集合
    private Iterator<AbstractHandler> it;

    /**
     * 使用构造方法初始化责任链 解析XML文件
     * 将子类实例化添加到list里面
     */
    public HandlerChain(String resourcePath){
     　　init(resourcePath);
        it = list.iterator();
    }
  
　　

/**
     * 初始化容器
     */
    private void init(String resourcePath){
        //创建SAX解析器
        SAXReader reader = new SAXReader();
        try {
            //读取XML文件，并构建document对象
            Document doc = reader.read(Thread.currentThread().getContextClassLoader().getResourceAsStream(resourcePath));

            //现在获取document的根元素
            Element root = doc.getRootElement();
            //获取所有子元素
            List<Element> childs = root.elements();
            //遍历，解析子元素的属性
            for(Element e:childs){//获取class属性
                String className = e.attributeValue("class");
                //将信息放入容器中
                childs.add(Class.forName(className).newInstance());
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

/**
     * 对list里面的审批经费权限进行判断
     * @param money
     */
   public void doFilter(int money){
        if(it.hasNext()){//如果有下一个就执行
            //使用list里面被实例化过的方法，在这里子类方法里面有一个判断
            //如果审批成功这输出，如果审批经费超出权限，这回都这里执行下list里面的下一个子类方法；
            it.next().execute(money,this);
        }
   }

}

三，有了这个中介后，我们的主方法就可以减少过多的耦合了

public class Main {
    public static void main(String[] args) {
        //实例化一个中介，在中介里面直接申请经费
      HandlerChain chain = new HandlerChain();
      chain.doFilter(50);
    }
}

XML文件

<?xml version="1.0" encoding="UTF-8"?>

<beans>
    <bean id="HandlerA" class="hadn.HandlerA" />
    <bean id="HandlerB" class="hadn.HandlerB" />
    <bean id="HandlerC" class="hadn.HandlerC" />
</beans>

　　

输出结果：A审核通过…………