【Java 行为型设计模式 III】责任链（职责）模式、状态模式详解

最新推荐文章于 2023-05-12 10:43:20 发布
最新推荐文章于 2023-05-12 10:43:20 发布
阅读量289 收藏
点赞数
分类专栏： IT界大神成长之路 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44598507/article/details/117107955
版权

 
愿你如阳光，明媚不忧伤。

目録

 

6. 责任链（职责）模式

Chain of Responsibility 为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。

责任链（职责）模式优点和缺点
  • 优点
  1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
  2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
  3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
  4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
  5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
  • 缺点
  1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
  2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
  3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。
责任链（职责）模式的应用场景
  1. 多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定。
  2. 可动态指定一组对象处理请求，或添加新的处理者。
  3. 需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。
责任链（职责）模式模式的结构
责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理；理解责任链模式应当理解其模式，而不是其具体实现。责任链模式的独到之处是将其节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。
1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。
抽象处理者Handler -next:Handler +setNext(Handler next) : void +getNext() : Handler handlerRequest(String request) : void 具体处理者1ConcreteHandler1 handlerRequest(String request) : void 具体处理者2ConcreteHandler2 handlerRequest(String request) : void 访问类Client +main() : void Realization Realization Aggregation
责任链（职责）模式的实现
package com.example.demo.controller;

public class ChainController {
    public static void main(String[] args) {
        // 组装责任链
        Leader teacher1 = new ClassAdviser();
        Leader teacher2 = new DepartmentHead();
        Leader teacher3 = new Dean();
        Leader teacher4 = new DeanOfStudies();
        teacher1.setNext(teacher2);
        teacher2.setNext(teacher3);
        teacher3.setNext(teacher4);
        // 提交请求
        teacher1.handleRequest(14);
    }
}

// 抽象处理者：领导类
abstract class Leader {
    private Leader next;

    public void setNext(Leader next) {
        this.next = next;
    }

    public Leader getNext() {
        return next;
    }

    // 处理请求的方法
    public abstract void handleRequest(int LeaveDays);
}

// 具体处理者1：班主任类
class ClassAdviser extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 2) {
            System.out.println("班主任批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者2：系主任类
class DepartmentHead extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 7) {
            System.out.println("系主任批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者3：院长类
class Dean extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 10) {
            System.out.println("院长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者4：教务处长类
class DeanOfStudies extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 20) {
            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}
-----------------------------------------------------------------
・【运行结果】
	教务处长批准您请假14天。

 

7. 状态模式

State 当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，用各个不同的类进行表示，系统处于哪种情况，直接使用相应的状态类对象进行处理，这样能把原来复杂的逻辑判断简单化，消除了 if-else、switch-case 等冗余语句，代码更有层次性，并且具备良好的扩展力。

状态模式优点和缺点
  • 优点
  1. 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
  2. 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
  3. 状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。
  • 缺点
  1. 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  2. 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
状态模式的应用场景
  1. 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  2. 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
状态模式的结构
状态模式把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。
1. 环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
2. 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。
抽象状态State +Handle(Context context) : void 具体状态1ConcreteState1 +Handle(Context context) : void 具体状态2ConcreteState2 +Handle(Context context) : void 环境类Context -state:State +Context() +setState(State state) : void +getState() : State +handle() : void 访问类Client +main() : void Realization Realization Aggregation
状态模式的实现
package com.example.demo.controller;

public class StateController {
    public static void main(String[] args) {
        // 创建环境
        StateContext stateContext = new StateContext();
        // 处理请求
        stateContext.Handle();
        stateContext.Handle();
        stateContext.Handle();
        stateContext.Handle();
    }
}

// 环境类
class StateContext {
    private State state;

    // 定义环境类的初始状态
    public StateContext() {
        this.state = new ConcreteStateA();
    }

    // 设置新状态
    public void setState(State state) {
        this.state = state;
    }

    // 读取状态
    public State getState() {
        return (state);
    }

    // 对请求做处理
    public void Handle() {
        state.Handle(this);
    }
}

//抽象状态类
abstract class State {
    public abstract void Handle(StateContext stateContext);
}

// 具体状态A类
class ConcreteStateA extends State {
    public void Handle(StateContext stateContext) {
        System.out.println("当前状态是 A.");
        stateContext.setState(new ConcreteStateB());
    }
}

// 具体状态B类
class ConcreteStateB extends State {
    public void Handle(StateContext stateContext) {
        System.out.println("当前状态是 B.");
        stateContext.setState(new ConcreteStateA());
    }
}
-----------------------------------------------------------------
・【运行结果】
	当前状态是 A.
	当前状态是 B.
	当前状态是 A.
	当前状态是 B.
状态模式的应用实例 I

用“状态模式”设计一个学生成绩的状态转换程序。

package com.example.demo.controller;

public class StateController {
    public static void main(String[] args) {
        ScoreContext account = new ScoreContext();
        System.out.println("学生成绩状态测试：");
        account.add(30);
        account.add(40);
        account.add(25);
        account.add(-15);
        account.add(-25);
    }
}

// 环境类
class ScoreContext {
    private AbstractState state;

    ScoreContext() {
        state = new LowState(this);
    }

    public void setState(AbstractState state) {
        this.state = state;
    }

    public AbstractState getState() {
        return state;
    }

    public void add(int score) {
        state.addScore(score);
    }
}

// 抽象状态类
abstract class AbstractState {
    // 环境
    protected ScoreContext scoreContext;
    // 状态名
    protected String stateName;
    // 分数
    protected int score;

    // 检查当前状态
    public abstract void checkState();

    public void addScore(int score) {
        this.score += score;
        System.out.print("加上：" + score + "分，  当前分数：" + score);
        checkState();
        System.out.println("分，  当前状态：" + scoreContext.getState().stateName);
    }
}

//具体状态类：不及格
class LowState extends AbstractState {
    public LowState(ScoreContext scoreContext) {
        this.scoreContext = scoreContext;
        stateName = "不及格";
        score = 0;
    }

    public LowState(AbstractState state) {
        scoreContext = state.scoreContext;
        stateName = "不及格";
        score = state.score;
    }

    public void checkState() {
        if (score >= 90) {
            scoreContext.setState(new HighState(this));
        } else if (score >= 60) {
            scoreContext.setState(new MiddleState(this));
        }
    }
}

//具体状态类：中等
class MiddleState extends AbstractState {
    public MiddleState(AbstractState state) {
        scoreContext = state.scoreContext;
        stateName = "中等";
        score = state.score;
    }

    public void checkState() {
        if (score < 60) {
            scoreContext.setState(new LowState(this));
        } else if (score >= 90) {
            scoreContext.setState(new HighState(this));
        }
    }
}

//具体状态类：优秀
class HighState extends AbstractState {
    public HighState(AbstractState state) {
        scoreContext = state.scoreContext;
        stateName = "优秀";
        score = state.score;
    }

    public void checkState() {
        if (score < 60) {
            scoreContext.setState(new LowState(this));
        } else if (score < 90) {
            scoreContext.setState(new MiddleState(this));
        }
    }
}
-----------------------------------------------------------------
・【运行结果】
	学生成绩状态测试：
	加上：30分，  当前分数：30分，  当前状态：不及格
	加上：40分，  当前分数：40分，  当前状态：中等
	加上：25分，  当前分数：25分，  当前状态：优秀
	加上：-15分，  当前分数：-15分，  当前状态：中等
	加上：-25分，  当前分数：-25分，  当前状态：不及格
状态模式的应用实例 II

用“状态模式”设计一个多线程的状态转换程序。

开始
获得CPU时间
停止
阻塞延缓
重新开始
新建
就绪
运行
死亡
阻塞 
package com.example.demo.controller;

public class StateInstanceController {
    public static void main(String[] args) {
        ThreadContext context = new ThreadContext();
        context.start();
        context.getCPU();
        context.suspend();
        context.resume();
        context.getCPU();
        context.stop();
    }
}

//环境类
class ThreadContext {
    private ThreadState state;

    ThreadContext() {
        state = new New();
    }

    public void setState(ThreadState state) {
        this.state = state;
    }

    public ThreadState getState() {
        return state;
    }

    public void start() {
        ((New) state).start(this);
    }

    public void getCPU() {
        ((Runnable) state).getCPU(this);
    }

    public void suspend() {
        ((Running) state).suspend(this);
    }

    public void stop() {
        ((Running) state).stop(this);
    }

    public void resume() {
        ((Blocked) state).resume(this);
    }
}

//抽象状态类：线程状态
abstract class ThreadState {
    protected String stateName; //状态名
}

//具体状态类：新建状态
class New extends ThreadState {
    public New() {
        stateName = "新建状态";
        System.out.println("当前线程处于：新建状态.");
    }

    public void start(ThreadContext hj) {
        System.out.print("调用start()方法-->");
        if (stateName.equals("新建状态")) {
            hj.setState(new Runnable());
        } else {
            System.out.println("当前线程不是新建状态，不能调用start()方法.");
        }
    }
}

//具体状态类：就绪状态
class Runnable extends ThreadState {
    public Runnable() {
        stateName = "就绪状态";
        System.out.println("当前线程处于：就绪状态.");
    }

    public void getCPU(ThreadContext hj) {
        System.out.print("获得CPU时间-->");
        if (stateName.equals("就绪状态")) {
            hj.setState(new Running());
        } else {
            System.out.println("当前线程不是就绪状态，不能获取CPU.");
        }
    }
}

//具体状态类：运行状态
class Running extends ThreadState {
    public Running() {
        stateName = "运行状态";
        System.out.println("当前线程处于：运行状态.");
    }

    public void suspend(ThreadContext hj) {
        System.out.print("调用suspend()方法-->");
        if (stateName.equals("运行状态")) {
            hj.setState(new Blocked());
        } else {
            System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
        }
    }

    public void stop(ThreadContext hj) {
        System.out.print("调用stop()方法-->");
        if (stateName.equals("运行状态")) {
            hj.setState(new Dead());
        } else {
            System.out.println("当前线程不是运行状态，不能调用stop()方法.");
        }
    }
}

//具体状态类：阻塞状态
class Blocked extends ThreadState {
    public Blocked() {
        stateName = "阻塞状态";
        System.out.println("当前线程处于：阻塞状态.");
    }

    public void resume(ThreadContext hj) {
        System.out.print("调用resume()方法-->");
        if (stateName.equals("阻塞状态")) {
            hj.setState(new Runnable());
        } else {
            System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");
        }
    }
}

//具体状态类：死亡状态
class Dead extends ThreadState {
    public Dead() {
        stateName = "死亡状态";
        System.out.println("当前线程处于：死亡状态.");
    }
}
-----------------------------------------------------------------
・【运行结果】
	当前线程处于：新建状态.
	调用start()方法-->当前线程处于：就绪状态.
	获得CPU时间-->当前线程处于：运行状态.
	调用suspend()方法-->当前线程处于：阻塞状态.
	调用resume()方法-->当前线程处于：就绪状态.
	获得CPU时间-->当前线程处于：运行状态.
	调用stop()方法-->当前线程处于：死亡状态.
状态模式的扩展

在有些情况下，可能有多个环境对象需要共享一组状态，这时需要引入享元模式，将这些具体状态对象放在集合中供程序共享。

  • 享元状态模式
享元抽象状态ShareState +Handle(ShareContext shareContext) : void 具体享元状态1ConcreteShareState1 +Handle(ShareContext shareContext) : void 具体享元状态2ConcreteShareState2 +Handle(ShareContext shareContext) : void 享元环境类ShareContext -stateSet:HashMap<String,ShareState> -shareState:ShareState +ShareContext() +setShareState(ShareState sharestate) : void +getShareState() : ShareState +handle() : void 访问类Client +main() : void Realization Realization Aggregation 
package com.example.demo.controller;

import java.util.HashMap;

public class ShareStateController {
    public static void main(String[] args) {
        ShareContext shareContext = new ShareContext();
        shareContext.handle();
        shareContext.handle();
        shareContext.handle();
        shareContext.handle();
    }
}

// 享元环境类
class ShareContext {
    private ShareState shareState;
    private HashMap<String, ShareState> shareStateHashMap = new HashMap<>();

    // 初始化享元状态
    public ShareContext() {
        shareState = new ConcreteShareState1();
        shareStateHashMap.put("c1", shareState);
        shareState = new ConcreteShareState2();
        shareStateHashMap.put("c2", shareState);
        shareState = getShareState("c1");
    }

    // 获取享元状态
    public ShareState getShareState(String key) {
        return shareStateHashMap.get(key);
    }

    // 设置新状态
    public void setShareState(ShareState shareState) {
        this.shareState = shareState;
    }

    // 对请求做处理
    public void handle() {
        shareState.handle(this);
    }

}

// 抽象享元状态类
abstract class ShareState {
    public abstract void handle(ShareContext shareContext);
}

// 具体享元状态类1
class ConcreteShareState1 extends ShareState {
    @Override
    public void handle(ShareContext shareContext) {
        System.out.println("当前状态为：具体享元状态1");
        shareContext.setShareState(shareContext.getShareState("c2"));
    }
}

// 具体享元状态类2
class ConcreteShareState2 extends ShareState {
    @Override
    public void handle(ShareContext shareContext) {
        System.out.println("当前状态为：具体享元状态2");
        shareContext.setShareState(shareContext.getShareState("c1"));
    }
}

-----------------------------------------------------------------
・【运行结果】
	当前状态为：具体享元状态1
	当前状态为：具体享元状态2
	当前状态为：具体享元状态1
	当前状态为：具体享元状态2

 

【每日一面】

说说状态模式和责任链模式的区别

状态模式和责任链模式都能消除 if-else 分支过多的问题。但在某些情况下，状态模式中的状态可以理解为责任，那么在这种情况下，两种模式都可以使用。
State：状态模式强调的是一个对象内在状态的改变，状态模式的各个状态对象知道自己要进入的下一个状态对象，各个状态间存在相互关系，彼此之间在一定条件下存在自动切换状态的效果，并且用户无法指定状态，只能设置初始状态。
Chain of Responsibility：责任链模式强调的是外部节点对象间的改变，责任链模式并不清楚其下一个节点处理对象，因为链式组装由客户端负责。
都是解决分支过多的问题。状态模式强调对象内部状态的改变，知道下一步的操作，而责任链模式强调外部节点间的改变，不知道下一步的操作

おうせき碩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
神经网络在化学领域的应用
禅与计算机程序设计艺术
07-01 157
神经网络在化学领域的应用 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming / TextGenWebUILLM 神经网络在化学领域的应用 1. 背景介绍
责任链模式和状态模式的区别
pzysoft的博客
03-18 2182
责任链模式：当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHander对象负责处理它。接收者和发送者都没有对方的明确信息，且链中的对象自己并不知道链的结构，在运行时自动确定。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用或指针，而不需要保持它所有的候选接受者。这也就大大降低了耦合度了。也就是说，我们可以随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵
责任链模式和状态模式对比（转）
weixin_30912051的博客
05-15 237
概述 　　常用23中设计模式中，有三种模式容易混淆，这三种模式即责任链模式、状态模式以及策略模式。现在想深入了解下这3种设计模式的区别，在网上找找之后，发现有一篇博客写的相对清晰。先将内容整理转载如下，也算是对知识的记载和传承； 状态模式与策略模式比较 1、定义： 　　　　状态模式：通过改变对象的内部状态而改变对象自身的行为，这个对象表现得就好像修改了它的类一样。 　　　 策略模式：定...
状态模式与职责链模式
狂奔的蜗牛
03-29 1853
在学习设计模式的时候发现状态模式与职责链模式特别的相似，当时没有能理解，现在回过头来看了看，查 了查资料，明白了一点，先把自己的理解写下来，在以后的学习继续深入学习 一、状态模式 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类 类图 Context类就是用户当前定义的一个状态，而抽象状态类State就是用来解决特定状态的方法
状态模式与责任链模式
qq_38515961的博客
09-23 769
文章目录一、状态模式 一、状态模式 状态模式定义：当一个对象的内在状态改变时允许其改变行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的逻辑简化。 State抽象状态类： public abstract class State{ public abstract void handle(Context context); } Context类，维护了一个State类型的对象，这个
状态模式 VS 职责链模式
忠麦一生
12-05 3958
这次合作开发过程中我们使用了一些设计模式，经过讨论对其理解深刻不少。之前在学习之中，我本以为自己已经理解了一些设计模式。但在这次的使用过程中，因为各自的理解不一造成了一定的碰撞，之后才发现自己的理解根本就站不住脚。于是，反复经过我们的讨论——实施——再讨论，发现理解的偏差，解决之。然后，才有了目前我们认为的比较稳定的，符合逻辑的理解。本篇博客要说的是我对状态模式和职责链模式的理解。这两个设计模式看
责任链模式、状态模式
erose的博客
12-06 675
责任链模式 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条传递链，知道有对象处理它为止。 优缺点 优点： 降低了对象之间的耦合度。该模式使得一个对象无需知道是哪一个对象处理其请求以及链的结构，发送者和接收者也无需拥有对方明确的消息。 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则； 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动他们的次序，也可以动
Java设计模式-责任链模式
cc_百川
04-01 293
对象由每一个对象对其下家的引用而连接起来形成一条链，即责任链。职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。
Java 设计模式（十四）：责任链模式
钱立清的博客
05-11 526
参考链接：职责链模式-Chain of Responsibility Pattern 1. 模式概述 很多情况下，在一个软件系统中可以处理某个请求的对象不止一个，例如我发起审批流程，需要先后经历项目经理、部门经理、技术总监、财务、CEO，他们可以构成一条处理审批的链式结构，审批单沿着这条链进行传递，这条链就称为责任链。责任链可以是一条直线、一个环或者一个树形结构，最常见的责任链是直线型，即沿着一条单向的链来传递请求。链上的每一个对象都是请求处理者，责任链模式可以将请求的处理者组织成一条链，并让请求沿着链传递
Hadoop安装配置与三种启动模式详解
king_weng的博客
11-09 2733
1、Hadoop简介 Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。Hadoop实现了一个分布式文件系统（Hadoop Distributed File System），简称HDFS。HDFS有高容错性的特点，并且设计用来部署在低廉的（low-cost）硬件上；而且它提供高吞吐量（high throughput）来访问应用程序的数据，适合那些有着超大数据集（large data ...
Java==POI报表详解
人生起落，生活苦甜，坚持追求！
06-22 1055
一.POI报表 在企业开发中，Excel报表是一种最常见的报表需求，Excel报表开发一般分为两种形式： （1）为了方便操作，基于Excel的报表批量上传数据 （2）通过java代码，快速生成Excel报表 POI报表简介： Apache POI是Apache软件基金会的开源项目，由Java编写的免费开源的跨平台的 Java API，Apache POI提供API给Java语言操作Microsoft Office的功能。 Excel分为两个大的版本Excel2003和Excel2007及以.
java中的缓存详解，一篇就够了
焚琴煮鹤呀的博客
02-28 8078
web应用框架
Spring源码——JDBC
等一杯咖啡的博客
10-27 1766
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第八章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 本章内容基于之前所说的Spring IOC 和 AOP功能...
Java设计模式之责任链模式（简单易懂）
小天狼星的博客
10-29 1万+
前言： 责任链模式（Chain of Responsibility）: 使多个对象都有机会处理同一请求，从而避免请求的发送者和接受者之间的耦合关系，每个对象都是一个处理节点，将这些对象连成一条链，并沿着这条链传递该请求。 网上有很多朋友已经对该模式介绍的非常详细了，也有案例帮助理解，可参考 Java设计模式之职责链模式 一篇文章搞懂Java设计模式之责任链模式_lzy_tinyjoy-CSDN博客_java责任链模式 ...
java设计模式---责任链模式详解
热门推荐
zhenghuishengq的博客
09-11 1万+
深入理解责任链模式
Java设计模式（五）—— 责任链模式
weixin_49561506的博客
03-27 991
设计模式之责任链模式
Java 责任链模式详解
最新发布
BASK2311的博客
05-12 1172
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它用于将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。在责任链模式中，有一个请求处理链条，每个处理请求的对象都是一个节点，当请求进入这个链条时，链条上的节点逐一判断是否能够处理该请求，如果可以，则处理；否则，将请求传递给下一个节点，直到请求被处理为止。
java设计模式之责任链模式、状态模式、策略模式
wang2963973852的博客
03-08 3347
若您对我的分享感兴趣可以访问：java设计模式专栏在常用的23中设计模式中，有三种模式容易混淆，这三种模式分别是：责任链模式、状态模式以及策略模式因此接下来我们把这三种模式放在一起讨论1、责任链模式（okHttp）职责链的本质是：不同的类对同一个问题的反应    责任链模式下处理者所处的位置决定了其功能，在这里，最后一个 Interceptor 一定是负责和服务器实际通讯的，重定向、缓存等一定是在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值