devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

七种常用的设计模式

作者：菜鸟追梦旅行 | 2024-04-01 10:44:53

赞

踩

设计模式

常用的七种设计模式：单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。

设计模式分类

设计模式根据工作的目的，分为创建型模式、结构型模式和行为型模式三类。

创建型模式：单例模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式。

结构型模式：适配器模式、代理模式、装饰器模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

软件设计七大原则(OOP原则)

开闭原则：对扩展开放，对修改关闭。
里氏替换原则：不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义。
依赖倒置原则：要面向接口编程，不要面向实现编程。
单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性。
接口隔离原则：要为各个类建立它们需要的专用接口。
迪米特法则：一个类应该保持对其它对象最少的了解，降低耦合度。
合成复用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

实际上，七大原则的目的只有一个：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。

1、单例模式：一个类只有一个实例，且该类能自行创建这个实例的一种模式
        ①单例类只有一个实例对象

        ②该单例对象必须由单例类自行创建

        ③单例类对外提供一个访问该单例的全局访问点

       ④、优点
                单例模式可以保证内存里只有一个实例，减少了内存的开销。
                可以避免对资源的多重占用。
                单例模式设置全局访问点，可以优化和共享资源的访问。
        ⑤、缺点
                单例模式一般没有接口，扩展困难。
                单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则

        饿汉式单例：类一旦加载就创建一个单例，保证在调用getInstance方法之前单例已经存在，这种饿汉式单例会造成空间浪费。

  1. public class Hungry {
  2.     private Hungry(){}
  3.     private final static Hungry HUNGRY = new Hungry();
  4.     public static Hungry getInstance(){
  5.         return HUNGRY;
  6.     }
  7. }

        懒汉式单例：为了避免内存空间浪费，采用懒汉式单例，即用到该单例对象的时候再创建。

  1. public class LazyMan {
  2.     private LazyMan(){};
  3.  
  4.     public static LazyMan lazyMan;
  5.  
  6.     public static LazyMan getInstance(){
  7.         if (lazyMan==null){
  8.             lazyMan = new LazyMan();
  9.         }
  10.         return lazyMan;
  11.     }
  12. }

这是最简单的懒汉式，但是，存在很大问题，单线程下这段代码没有问题，但是在多线程下有很大问题。

  1. public class LazyMan {
  2.     private LazyMan(){
  3.         System.out.println(Thread.currentThread().getName()+"");
  4.     }
  5.  
  6.     public static LazyMan lazyMan;
  7.  
  8.     public static LazyMan getInstance(){
  9.         if (lazyMan==null){
  10.             lazyMan = new LazyMan();
  11.         }
  12.         return lazyMan;
  13.     }
  14.  
  15.     public static void main(String[] args) {
  16.         for(int i=0;i<10;i++){
  17.             new Thread(()->{
  18.                 lazyMan.getInstance();
  19.             }).start();
  20.         }
  21.     }
  22. }

 会发现结果都不一样，因此，并发情况下，这段代码是有问题的。我们需要进行两端检测，进行“加锁”：synchronized (Singleton.class)。

  1. public class LazyMan {
  2.     private LazyMan(){
  3.         System.out.println(Thread.currentThread().getName()+"");
  4.     }
  5.  
  6.     public static LazyMan lazyMan;
  7.  
  8.     public static LazyMan getInstance(){
  9.         if (lazyMan==null){        //第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入
  10.             synchronized (LazyMan.class){    //第一层锁，保证只有一个线程进入
  11.                 //双重检查，防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象，故在创建对象之前无引用指向对象，所有线程均可进入第一层检查)
  12.                 //当某一线程获得锁创建一个LazyMan对象时,即已有引用指向对象，lazyMan不为空，从而保证只会创建一个对象
  13.                 //假设没有第二层检查，那么第一个线程创建完对象释放锁后，后面进入对象也会创建对象，会产生多个对象
  14.                 if(lazyMan==null){    //第二层检查
  15.                     //synchronized关键字作用为禁止指令重排，保证返回Singleton对象一定在创建对象后
  16.                     lazyMan = new LazyMan();        //这行代码存在的问题，不能保证原子性
  17. 实际上会执行以下内容：
  18.                     //(1)在堆上开辟空间；(2)属性初始化;(3)引用指向对象
  19.                     //假设以上三个内容为三条单独指令，因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),当单例模式中存在普通变量需要在构造方法中进行初始化操作时，单线程情况下，顺序重排没有影响；但在多线程情况下，假如线程1执行lazyMan = new LazyMan()语句时先1再3，由于系统调度线程2的原因没来得及执行步骤2，但此时已有引用指向对象也就是lazyMan!=null，故线程2在第一次检查时不满足条件直接返回lazyMan，此时lazyMan为null
  20.                     //synchronized关键字可保证lazyMan = new LazyMan()语句执行顺序为123，因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断)，但能确保的是只要lazyMan!=0，就表明一定执行了属性初始化操作；而若在步骤3之前被打断，此时lazyMan依旧为null，其他线程可进入第一层检查向下执行创建对象
  21.                 }
  22.             }
  23.         }
  24.         return lazyMan;
  25.     }
  26.  
  27.     public static void main(String[] args) {
  28.         for(int i=0;i<10;i++){
  29.             new Thread(()->{
  30.                 lazyMan.getInstance();
  31.             }).start();
  32.         }
  33.     }
  34. }

 可以看到结果都是只有一个，按理来说是没有问题，实际上不是，上述标注行代码存在问题的，不是一个原子性操作。

        静态内部类单例：是不安全，存在问题的，是不安全，存在问题的(修改过的懒汉式单例也是如此)。

  1. public class Inner {
  2.     private Inner(){}
  3.     public static Inner getInstance(){
  4.         return InnerClass.INNER;
  5.     }
  6.     public static class InnerClass{
  7.         private static final Inner INNER = new Inner();
  8.     }
  9. }

2、工厂方法模式：实例化对象不是用new，用工厂方法替代。将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

        简单工厂模式：用来生产同一等级架构中的任意产品(对于增加新的产品，需要修改已有代码)
在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例。

接下来创建一个接口，两个实现类，一个工厂，一个测试类

  1. //创建手机接口
  2. public interface Phone {
  3.     void name();
  4. }
  5. //创建华为实现类
  6. public class HuaWei implements Phone{
  7.     @Override
  8.     public void name() {
  9.         System.out.println("华为手机");
  10.     }
  11. }
  12. //创建小米实现类
  13. public class XiaoMi implements Phone{
  14.     @Override
  15.     public void name() {
  16.         System.out.println("小米手机");
  17.     }
  18. }
  19. //创建工厂
  20. public class PhoneFactory {
  21.     public static Phone getPhone(String phone){
  22.         if(phone.equals("华为")){
  23.             return new HuaWei();
  24.         }else if(phone.equals("小米")){
  25.             return  new XiaoMi();
  26.         }else {
  27.             return null;
  28.         }
  29.     }
  30. }
  31. //测试类
  32. public class Consumer {
  33.     public static void main(String[] args) {
  34.         Phone p1= PhoneFactory.getPhone("华为");
  35.         Phone p2= PhoneFactory.getPhone("小米");
  36.         p1.name();
  37.         p2.name();
  38.     }
  39. }

得到测试结果

        华为手机
        小米手机

我们通过创建一个PhoneFactory类，成功的完成工厂的创建。我们在创建对象时，也就不需要直接创建对象，而是可以通过创建工厂，这样大大的降低了代码的耦合性。但是，静态工厂模式是不能添加数据的。比如说，我们想添加一个“Oppo”手机类，你不直接修改PhoneFactory工厂代码，是不能实现的。所以，就有了第二种的工厂方法模式。

        工厂方法模式：用来生产同一等级架构中的固定产品，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。(支持增加任意产品)

  1. //创建手机接口
  2. public interface Phone {
  3.     void name();
  4. }
  5. //创建华为实现类
  6. public class HuaWei implements Phone{
  7.     @Override
  8.     public void name() {
  9.         System.out.println("华为手机");
  10.     }
  11. }
  12. //创建手机工厂接口
  13. public interface PhoneFactory {
  14.     Phone getPhone();
  15. }
  16. //创建华为工厂
  17. public class HuaWeiFactory implements PhoneFactory{
  18.     @Override
  19.     public Phone getPhone() {
  20.         return new HuaWei();
  21.     }
  22. }
  23. //测试类
  24. public class Consumer {
  25.     public static void main(String[] args) {
  26.         Phone phone = new HuaWeiFactory().getPhone();
  27.         phone.name();
  28.     }
  29. }

得到测试结果

        华为手机

我们创建了手机工厂接口PhoneFactory，再创建华为工厂HuaWeiFactory实现工厂，这样就可以通过HuaWeiFactory创建对象。增加新的具体工厂和产品族很方便，比如说，我们想要增加小米，只需要创建一个小米工厂XiaoMiFactory实现手机工厂接口PhoneFactory，合理的解决的简单工厂模式不能修改代码的缺点。但是，在现实使用中，简单工厂模式占绝大多数。

简单工厂模式与工厂方法模式比较：

结构的复杂度：简单工厂模式占优。
代码的复杂度：简单工厂模式占优。
编程的复杂度：简单工厂模式占优。
管理的复杂的：简单工厂模式占优。
因此，虽然简单工厂模式不符合设计模式，但是实际使用远大于工厂方法模式。

3、抽象工厂模式：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类(围绕一个超级工厂创建其他工厂，该超级工厂称为工厂的工厂)

抽象工厂模式得主要角色：

        1、抽象工厂(Abstract Factory)提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
2具体工厂(Concrete Factory)主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3抽象产品(Product)定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4具体产品(ConcreteProduct)实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

  1. //电脑接口
  2. public interface Computer {
  3.     void play();
  4.     void watch();
  5. }
  6. //创建华为电脑对象
  7. public class HuaWeiComputer implements Computer{
  8.     @Override
  9.     public void play() {
  10.         System.out.println("HuaWei's play!");
  11.     }
  12.  
  13.     @Override
  14.     public void watch() {
  15.         System.out.println("HuaWei's watch!");
  16.     }
  17. }
  18. //手机接口
  19. public interface Phone {
  20.     void send();
  21.     void call();
  22. }
  23. //创建华为手机对象
  24. public class HuaWeiPhone implements Phone{
  25.     @Override
  26.     public void send() {
  27.         System.out.println("HuaWei's send");
  28.     }
  29.  
  30.     @Override
  31.     public void call() {
  32.         System.out.println("HuaWei's call");
  33.     }
  34. }
  35. //抽象工厂
  36. public interface IProductFactory {
  37.     //生产手机
  38.     Phone phone();
  39.     //生产电脑
  40.     Computer computer();
  41. }
  42. //创建华为工厂
  43. public class HuaWeiFactory implements IProductFactory{
  44.     @Override
  45.     public Phone phone() {
  46.         return new HuaWeiPhone();
  47.     }
  48.  
  49.     @Override
  50.     public Computer computer() {
  51.         return new HuaWeiComputer();
  52.     }
  53. }
  54. //测试类
  55. public class Consumer {
  56.     public static void main(String[] args) {
  57.         HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
  58.         Phone phone = huaWeiFactory.phone();
  59.         phone.call();
  60.         phone.send();
  61.         Computer computer = huaWeiFactory.computer();
  62.         computer.play();
  63.         computer.watch();
  64.     }
  65. }

得到测试结果

        HuaWei's call
        HuaWei's send
        HuaWei's play!
        HuaWei's watch!

我们通过创建一个抽象工厂完成了对具体工厂的创建，只需要传入参数就可以实例化对象。具体产品在应用层的代码隔离，无需关心创建的细节将一个系列的产品统一到一起创建。将一系列产品规划到一起创建。但是，抽象工厂模式也存在着缺点。规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难，不可以增加产品，只能增加品牌。

4、代理模式：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

        静态代理模式：

        角色分析：           

        1、抽象角色：一般会使用接口或抽象类来解决

        2、真实角色：被代理的角色

        3、代理角色：代理真实角色，代理真实角色后我们会进行一些附属操作

        4、访问角色：访问代理对象的人

  1. //租房
  2. public interface Rent {
  3.     void rent();
  4. }
  5. //房东
  6. public class Master implements Rent{
  7.     @Override
  8.     public void rent() {
  9.         System.out.println("Master rent");
  10.     }
  11. }
  12. //中介
  13. public class Proxy implements Rent{
  14.     private Master master;
  15.  
  16.     public Proxy() {
  17.     }
  18.  
  19.     public Proxy(Master master) {
  20.         this.master = master;
  21.     }
  22.  
  23.     @Override
  24.     public void rent() {
  25.         see();
  26.         master.rent();
  27.         fare();
  28.     }
  29.     //看房
  30.     public void see(){
  31.         System.out.println("see");
  32.     }
  33.     //收费
  34.     public void fare(){
  35.         System.out.println("fare");
  36.     }
  37. }
  38. //测试类
  39. public class Consumer {
  40.     public static void main(String[] args) {
  41.         Master master = new Master();
  42.         //进行代理
  43.         Proxy proxy = new Proxy(master);
  44.         //不需要通过对象，直接通过代理完成响应业务
  45.         proxy.rent();
  46.     }
  47. }

得到测试结果

        see
        Master rent
        fare

可以从上述代码看出，我们通过创建中介这一代理完成了租房，并且还有看房、收费的附属操作。我们不需要使用房东对象，通过使用代理中介就可以完成操作。 

代理模式优点：可以使真实角色的操作更加纯粹!不用去关注一些公共的业务，公共也就可以交给代理角色，实现了业务的分工，公共业务发生扩展的时候，方便集中管理!
代理模式缺点：一个真实角色就会产生一个代理角色;代码量会翻倍开发效率会变低，也许，这样无法理解到代理模式的好处。举个例子也许能更好理解，比如说我们想要在原有固定功能上新增业务，按照开闭原则我们是不能对原有代码进行修改的。但是我们可以通过代理模式，增加代理，在实现原有功能的情况下写入新的功能，创建对象时也就可以使用代理，完成操作。

 动态代理模式：虽然静态代理模式可以很好的解决开闭原则，但是每有一个真实角色就会产生一个代理，代码量翻倍过于臃肿，开发效率较低。因此，我们就使用动态代理模式进行设计。

  1. //接口
  2. public interface IUserService {
  3.     void add();
  4.     void delete();
  5.     void update();
  6.     void query();
  7.  
  8. }
  9. //实现类
  10. public class UserServiceImpl implements IUserService {
  11.     @Override
  12.     public void add() {
  13.         System.out.println("add");
  14.     }
  15.  
  16.     @Override
  17.     public void delete() {
  18.         System.out.println("delete");
  19.     }
  20.  
  21.     @Override
  22.     public void update() {
  23.         System.out.println("update");
  24.     }
  25.  
  26.     @Override
  27.     public void query() {
  28.         System.out.println("query");
  29.     }
  30. }
  31. import java.lang.reflect.InvocationHandler;
  32. import java.lang.reflect.Method;
  33. import java.lang.reflect.Proxy;
  34. //自动生成动态代理类模板
  35. public class ProxyInvocationHandler implements InvocationHandler {
  36.     //被代理接口
  37.     private Object target;
  38.    
  39.     public void setTarget(Object target) {
  40.         this.target = target;
  41.     }
  42.      //得到代理类
  43.     public Object getProxy() {
  44.         return Proxy.newProxyInstance(getClass().getClassLoader(), target.getClass().getInterfaces(), this);
  45.     }
  46.     public void log(String s) {
  47.         System.out.println("[debug]:" + s);
  48.     }
  49.     //得到代理类
  50.     @Override
  51.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  52.         log(method.getName());
  53.         Object result = method.invoke(target, args);
  54.         return result;
  55.     }
  56. }
  57. //测试类
  58. public class Consumer {
  59.     public static void main(String[] args) {
  60.         UserServiceImpl userService = new UserServiceImpl();
  61.         ProxyInvocationHandler handler = new ProxyInvocationHandler();
  62.         //设置代理对象
  63.         handler.setTarget(userService);
  64.         //生成代理类
  65.         IUserService proxy = (IUserService)handler.getProxy();
  66.         proxy.add();
  67.         proxy.query();
  68.     }
  69. }

得到测试结果

        [debug]:add
        add
        [debug]:query
        query

通过测试我们可以顺利的使用动态代理模式完成一系列操作，当我们想要添加附属操作时，我们只需要在模板中进行添加。优点：①可以使真实角色的操作更加纯粹!不用去关注一些公共的业务。②公共也就可以交给代理角色!实现了业务的分工。③公共业务发生扩展的时候，方便集中管理。④一个动态代理类代理的是一个接口，一般就是对应的一类业务。⑤一个动态代理类可以代理多个类，只要是实现了同一个接口即可!

5、装饰者模式：动态的将新功能附加到对象上。在对象功能的拓展方面，比继承更有弹性。同时装饰者模式也体现了开闭原则。

        角色分析：

        1、抽象构件(Component)角色:定义一个抽象接口以规范准备接收附加责任的对象。
        2、具体构件(ConcreteComponent)角色:实现抽象构件，通过装饰角色为其添加一些职责。
        3、抽象装饰(Decorator)角色:继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
        4、具体装饰(ConcreteDecorator)角色:实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

  1. //定义抽象类
  2. public abstract class Drink {
  3.     public abstract double cost();
  4. }
  5. //定义两个抽象类的实现类
  6. public class Juice extends Drink{
  7.     @Override
  8.     public double cost() {
  9.         System.out.println("juice: "+16);
  10.         return 16;
  11.     }
  12. }
  13. public class Milk extends Drink{
  14.     @Override
  15.     public double cost() {
  16.         System.out.println("milk: "+12);
  17.         return 12;
  18.     }
  19. }
  20. //定义装饰抽象类
  21. public abstract class Decorator extends Drink {
  22.     public abstract double cost();
  23. }
  24. //定义两个装饰具体实现类
  25. public class Chocolate extends Decorator{
  26.     private final static double COST = 4;
  27.     private Drink drink;
  28.  
  29.     public Chocolate(Drink drink) {
  30.         this.drink = drink;
  31.     }
  32.  
  33.     @Override
  34.     public double cost() {
  35.         System.out.println("chocolate:"+4);
  36.         return COST+drink.cost();
  37.     }
  38. }
  39. public class Pudding extends Decorator{
  40.     private final static double COST = 5;
  41.     private Drink drink;
  42.  
  43.     public Pudding(Drink drink) {
  44.         this.drink = drink;
  45.     }
  46.  
  47.     @Override
  48.     public double cost() {
  49.         System.out.println("pudding:"+5);
  50.         return COST+drink.cost();
  51.     }
  52. }
  53. //测试类
  54. public class Test {
  55.     public static void main(String[] args) {
  56.         Drink milk = new Milk();
  57.         milk = new Pudding(milk);
  58.         milk = new Chocolate(milk);
  59.         System.out.println(milk.cost());
  60.     }
  61. }

得到测试结果

        chocolate:4
        pudding:5
        milk: 12
        21.0

 

可以看到非常简单的就能够完成具体构件和具体装饰的组合。也可以看到结构也非常简洁明，具体构件在自己的package中，具体装饰也在自己的package中。我们不管是想要增加具体构件还是具体配饰，都可以在各自的package中添加。对已有的代码不需要进行任何操作，就算新加的有bug也不会影响原有代码的操作。

6、观察者模式：对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

        观察者模式有点：

        1、降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。

        2、目标与观察者之间建立了一套触发机制。

  1. //定义观察者接口
  2. public interface Observer {
  3.     void response();
  4. }
  5. //具体化观察者1
  6. public class Observer1 implements Observer{
  7.     @Override
  8.     public void response() {
  9.         System.out.println("Observer1 action");
  10.     }
  11. }
  12. //具体化观察者2
  13. public class Observer2 implements Observer{
  14.     @Override
  15.     public void response() {
  16.         System.out.println("Observer2 action");
  17.     }
  18. }
  19. //抽象目标
  20. public abstract class Subject {
  21.     //创建观察者集合
  22.     protected ArrayList<Observer> array = new ArrayList<Observer>();
  23.     //增加观察者
  24.     public void add(Observer observer){
  25.         array.add(observer);
  26.     }
  27.     //删除观察者
  28.     public void remove(Observer observer){
  29.         array.remove(observer);
  30.     }
  31.     //通知观察者方法
  32.     public abstract void notifyObserver();
  33. }
  34. //具体化目标
  35. public class Subject1 extends Subject{
  36.     @Override
  37.     public void notifyObserver() {
  38.         for (Observer observer :array){
  39.             observer.response();
  40.         }
  41.     }
  42. }
  43. //测试类
  44. public class Test {
  45.     public static void main(String[] args) {
  46.         Subject subject = new Subject1();
  47.         Observer obs1 = new Observer1();
  48.         Observer obs2 = new Observer2();
  49.         subject.add(obs1);
  50.         subject.add(obs2);
  51.         subject.notifyObserver();
  52.     }
  53. }

得到测试结果：

        Observer1 action
        Observer2 action

通过测试我们可以看到，我们不需要建立太多观察者和具体目标之间的联系，大大降低了目标与观察者之间的耦合关系。并且结构也十分简单明了，观察者和目标分别在各自的package包下。当我们想要添加观察者时，只需要在观察者包下进行添加，实现Observer接口就可以了。

7、责任链模式：一种处理请求的模式，它让多个处理器都有机会处理该诘求，直到其中某个处理成功为止。责任链模式把多个处理器串成链，然后让请求在链上传递。
        责任链模式的主要角色
        抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
        具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
        客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
        责任链模式优点
                降低了对象之间的耦合度。处理者不需要知道客户的任何信息，客户也不要知道处理者是如何实现方法的。
                提高了系统的灵活性。当我们想要新增处理器到整个链条中时，所付出的代价是非常小的
        责任链模式缺点
                降低了系统的性能。对比较长的职责链，请求的处理可能涉及多个处理对象
                不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。

  1. //抽象处理者
  2. public abstract class Handler {
  3.     private Handler next;
  4.     public void setNext(Handler next) { this.next = next; }
  5.     public Handler getNext() { return next; }
  6.  
  7.     //处理请求
  8.     public abstract void handleRequest(int info);
  9. }
  10. //具体处理者1
  11. public class Handler1 extends Handler{
  12.     @Override
  13.     public void handleRequest(int info) {
  14.         if (info <10){
  15.             System.out.println("Handler1完成处理");
  16.         }else {
  17.             if (getNext()!=null){
  18.                 getNext().handleRequest(info);
  19.             }else {
  20.                 System.out.println("没有处理者进行处理");
  21.             }
  22.         }
  23.     }
  24. }
  25. //具体处理者2
  26. public class Handler2 extends Handler{
  27.     @Override
  28.     public void handleRequest(int info) {
  29.         if (info <20&&info>10){
  30.             System.out.println("Handler2完成处理");
  31.         }else {
  32.             if (getNext()!=null){
  33.                 getNext().handleRequest(info);
  34.             }else {
  35.                 System.out.println("没有处理者进行处理");
  36.             }
  37.         }
  38.     }
  39. }
  40. 测试类
  41. public class Test {
  42.     public static void main(String[] args) {
  43.         Handler handler1 = new Handler1();
  44.         Handler handler2 = new Handler2();
  45.         handler1.setNext(handler2);
  46.         handler1.handleRequest(5);
  47.         handler1.handleRequest(15);
  48.         handler1.handleRequest(25);
  49.     }
  50. }

得到测试结果：

Handler1完成处理
Handler2完成处理
没有处理者进行处理

通过测试结果我们看到，5交给了Handler1处理，15交给了Handler2处理，而25则没有处理者处理。请求者根本不需要参与处理，只需要提交数据就可以完成功能的处理，完全不需要管是哪个处理者进行处理的。当我们想要继续添加处理者时，这只需要再次添加就可以了，也不会对之前的代码造成影响。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/348543?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号