传统责任链模式和变种责任链模式

一、传统责任链模式

传统责任链模式是事件在链条中的某一节进行处理,而变种责任链模式是事件会在链条的每一节都进行处理,每一节担当的责任各不相同。

1.一个接口或抽象类

定义一个接口,一个方法,判断数值是否正确。这里简单的自定义判断数值是否正确,规则随便怎么写。

package com.ykq;

/**
 * 数值处理接口类
 */
public interface NumInf {
    /**
     * 检查数值是否正确
     *
     * @param num int
     * @return boolean
     */
    public boolean checkNumCurrent(int num);
}
2.多个实现类

多个实现类都实现上面的接口,重写方法。这样责任链的每个类都有一个相同的方法。

1.小于5的数值定义该数值正确或错误
package com.impl;

import com.ykq.NumInf;

/**
 * <= 5的数值处理
 */
public class FiveImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 5 值的数值判断!");
        if(num <= 5){
            // 当数值小于5时,由该类处理判断是否正确
            // 此处校验规则由该类自己决定,不受其他类干涉
            if(num % 2 == 0){
                return true;
            } else {
                return false;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}
2.小于10的数值定义该数值正确或错误
package com.impl;

import com.ykq.NumInf;

/**
 * <= 10的处理
 */
public class TenImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 10 值的数值判断!");
        if(num <= 10){
            // 当数值小于10时,由该类处理判断是否正确
            // 此处校验规则由该类自己决定,不受其他类干涉
            if(num % 2 == 0){
                return false;
            } else {
                return true;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}
3.小于100的数值定义该数值正确或错误
package com.impl;

import com.ykq.NumInf;

/**
 * <= 100的数值处理
 */
public class HundredImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 100 值的数值判断!");
        if(num <= 100){
            // 当数值小于100时,由该类处理判断是否正确
            // 此处校验规则由该类自己决定,不受其他类干涉
            switch(num){
                case 20:
                case 30:
                case 40:
                case 50:
                case 60:
                case 70:
                case 80:
                case 90:
                    return true;
                default:
                    return false;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}
4.小于1000的数值定义该数值正确或错误
package com.impl;

import com.ykq.NumInf;

/**
 * <= 1000的数值处理
 */
public class ThousandImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 <= 1000 值的数值判断!");
        if(num <= 1000){
            // 当数值小于1000时,由该类处理判断是否正确
            // 此处校验规则由该类自己决定,不受其他类干涉
            switch(num){
                case 200:
                case 300:
                case 400:
                case 500:
                case 600:
                case 700:
                case 800:
                case 900:
                    return false;
                default:
                    return true;
            }
        } else {
            return nextNumImpl.checkNumCurrent(num);
        }
    }
}
5.更大的数值定义该数值正确或错误
package com.impl;

import com.ykq.NumInf;

/**
 * 更大的数值处理
 */
public class BiggerImpl implements NumInf {
    private NumInf nextNumImpl;

    public NumInf getNextNumImpl() {
        return nextNumImpl;
    }

    public void setNextNumImpl(NumInf nextNumImpl) {
        this.nextNumImpl = nextNumImpl;
    }

    public boolean checkNumCurrent(int num) {
        System.out.println("进入 > 1000 值的数值判断!");
        return false;
    }
}

那么实际上,对于上述责任链,我还可以继续扩充责任链的节点。小于0的方向可以扩充,大于1000的方向也可以扩充。

3.main实现

main的实现可以设置链条的每一节,这样使得责任链具有灵活性。
下面的实现,则是把上面已有的节点类,都加入了进来。
那么实际上我少一个或两个节点,对于数值的判断正误,很可能的接口就是返回的结果不一样。

package com;

import com.impl.*;
import com.ykq.NumInf;

public class MainClass {
    public static void main(String[] args){
        FiveImpl fiveImpl = new FiveImpl();
        TenImpl tenImpl = new TenImpl();
        HundredImpl hundredImpl = new HundredImpl();
        ThousandImpl thousandImpl = new ThousandImpl();
        BiggerImpl biggerImpl = new BiggerImpl();
        fiveImpl.setNextNumImpl(tenImpl);
        tenImpl.setNextNumImpl(hundredImpl);
        hundredImpl.setNextNumImpl(thousandImpl);
        thousandImpl.setNextNumImpl(biggerImpl);
        // 判断数boolean值
        System.out.println(fiveImpl.checkNumCurrent(999));
    }
}

二、变种责任链模式

我们常见的变种责任链就是过滤器。Filter提供一个接口,我们实现接口,然后通过链条的方式走到下一个过滤器。

已标记关键词 清除标记
相关推荐
主要是介绍各种格式流行的软件设计模式,对于程序员的进一步提升起推进作用,有时间可以随便翻翻~~ 23种设计模式汇集 如果你还不了解设计模式是什么的话? 那就先看设计模式引言 ! 学习 GoF 设计模式的重要性 建筑和软件中模式之异同 A. 创建模式 设计模式之 Singleton(单态/单件) 阎宏博士讲解:单例(Singleton)模式 保证一个类只有一个实例,并提供一个访问它的全局访问点 设计模式之 Factory(工厂方法和抽象工厂) 使用工厂模式就象使用 new 一样频繁. 设计模式之 Builder 汽车由车轮 方向盘 发动机很多部件组成,同时,将这些部件组装成汽车也是一件复杂的工作,Builder 模式就是将这两 种情况分开进行。 设计模式之 Prototype(原型) 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。 B. 结构模式 设计模式之 Adapter(适配器) 使用类再生的两个方式:组合(new)和继承(extends),这个已经在 thinking in java中提到过. 设计模式之 Proxy(代理) 以 Jive 为例,剖析代理模式在用户级别授权机制上的应用 设计模式之 Facade(门面?) 可扩展的使用 JDBC针对不同的数据库编程,Facade提供了一种灵活的实现. 设计模式之 Composite(组合) 就是将类用树形结构组合成一个单位.你向别人介绍你是某单位,你是单位中的一个元素,别人和你做买卖,相当于 和单位做买卖。文章中还对 Jive再进行了剖析。 设计模式之 Decorator(装饰器) Decorator 是个油漆工,给你的东东的外表刷上美丽的颜色. 设计模式之 Bridge(桥连) 将牛郎织女分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合) 设计模式之 Flyweight(共享元) 提供 Java运行性能,降低小而大量重复的类的开销. C. 行为模式 设计模式之 Command(命令) 什么是将行为封装,Command 是最好的说明. 设计模式之 Observer(观察者) 介绍如何使用 Java API 提供的现成 Observer 设计模式之 Iterator(迭代器) 这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中, 直接使用 Iterator 进行对象遍历。 设计模式之 Template(模板方法) 实际上向你介绍了为什么要使用 Java 抽象类,该模式原理简单,使用很普遍. 设计模式之 Strategy(策略) 不同算法各自封装,用户端可随意挑选需要的算法. 设计模式之 Chain of Responsibility(责任链) 各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个. 设计模式之 Mediator(中介) Mediator 很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以. 设计模式之 State(状态) 状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换. 设计模式之 Memento(注释状态?) 很简单一个模式,就是在内存中保留原来数据的拷贝. 设计模式之 Interpreter(解释器) 主要用来对语言的分析,应用机会不多. 设计模式之 Visitor(访问者) 访问者在进行访问时,完成一系列实质性操作,而且还可以扩展. 设计模式引言 设计面向对象软件比较困难,而设计可复用的面向对象软件就更加困难。你必须找到相关的对象,以适当的粒度将它们归 类,再定义类的接口和继承层次,建立对象之间的基本关系。你的设计应该对手头的问题有针对性,同时对将来的问题和需求 也要有足够的通用性。 你也希望避免重复设计或尽可能少做重复设计。有经验的面向对象设计者会告诉你,要一下子就得到复用性和灵活性好的设计, 即使不是不可能的至少也是非常困难的。一个设计在最终完成之前常要被复用好几次,而且每一次都有所修改。 有经验的面向对象设计者的确能做出良好的设计,而新手则面对众多选择无从下手,总是求助于以前使用过的非面向对象 技术。新手需要花费较长时间领会良好的面向对象设计是怎么回事。有经验的设计者显然知道一些新手所不知道的东西,这又 是什么呢? 内行的设计者知道:不是解决任何问题都要从头做起。他们更愿意复用以前使用过的解决方案。当找到一个好的解决方案,他 们会一遍又一遍地使用。这些经验是他们成为内行的部分原因。因此,你会在许多面向对象系统中看到类和相互通信的对象( c o m
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页