Java设计模式--行为者模式（一）

最新推荐文章于 2022-06-19 19:44:54 发布

头发慢点掉的小马

最新推荐文章于 2022-06-19 19:44:54 发布

阅读量802

点赞数 1

分类专栏：设计模式文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/m0_57098080/article/details/124552865

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

(1)责任链模式

概念：

主要是每个接受者都包含了另一个接受者的引用。如果这个对象不能处理这个请求，就会被相同的请求传给下一个接受者。（这就形成了一条责任链）

应用实例： 1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

代码实现：

package com.study.shejiPattern.responability;

/**8
 * 处理的父类
 */
public abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    //责任链中的下一个元素
    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message){
        if(this.level <= level){
            write(message);
        }
        if(nextLogger !=null){
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);

}

package com.study.shejiPattern.responability;

public class ErrorLogger extends AbstractLogger {

    public ErrorLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}

package com.study.shejiPattern.responability;

public class FileLogger extends AbstractLogger {

    public FileLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }

}

package com.study.shejiPattern.responability;

public class ConsoleLogger extends AbstractLogger {
    public ConsoleLogger(int level) {
        this.level=level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}

package com.study.shejiPattern.responability;

public class Test {
    private static AbstractLogger getChainOfLoggers(){
        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);
        return errorLogger;
    }

    public static void main(String[] args) {
        AbstractLogger loggerChain=getChainOfLoggers();
        loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
        loggerChain.logMessage(AbstractLogger.DEBUG,
                "This is a debug level information.");
        loggerChain.logMessage(AbstractLogger.ERROR,
                "This is an error information.");
    }
}

(2)命令模式

概念：

就像一个将军传达命令给士兵（有多个士兵）将军只需要发送命令就可以，具体哪个士兵执行不在意这里的实现

存在buy和sell两个士兵，执行者只需要发送执行，不用就管这么执行

代码实现：

order：

/**8
 * buy的命令
 */
public class BuyOrder implements Order {
    private Stock abcStock;

    public BuyOrder(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.buy();
    }
}

public class SellOrder implements Order {
    private Stock abcStock;

    public SellOrder(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.sell();
    }
}

stock：

/***
 * buy和sell的操作
 */
public class Stock {
    private String name = "ABC";
    private int quantity = 10;

    public void buy(){
        System.out.println("Stock [ Name: "+name+",Quantity: " + quantity +" ] bought");
    }
    public void sell(){
        System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");
    }
}

broker：

/***
 * 命令列表
 */
public class Broker {
    private List<Order> orderList = new ArrayList<Order>();

    public void takeOrder(Order order){
        orderList.add(order);
    }

    public void placeOrders(){
        for (Order order : orderList) {
            order.execute();
        }
        orderList.clear();
    }
}

client：

public class CommandPatternDemo {
    public static void main(String[] args) {
        Stock abcStock = new Stock();

        BuyOrder buyStockOrder = new BuyOrder(abcStock);
        SellOrder sellStockOrder = new SellOrder(abcStock);

        Broker broker = new Broker();
        broker.takeOrder(buyStockOrder);
        broker.takeOrder(sellStockOrder);

        broker.placeOrders();
    }
}

(3)解释器模式

实现了一个表达式接口，这个接口解释了一个特定的上下文。（利用场景较少）

(4)迭代器模式

概念：

首先是Java和.Net编程环境中非常常用的设计模式。用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

代码实现：

public class NameRepository implements Container {
    public  String[] names={"mq","lzf","sa","sj"};
    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {
        int index=0;
        @Override
        public boolean hasNext() {
            if(index<names.length){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

public class Client {
    public static void main(String[] args) {
        NameRepository nameRepository=new NameRepository();
        for(Iterator iter = nameRepository.getIterator(); iter.hasNext();){
            String name = (String)iter.next();
            System.out.println("Name : " + name);
        }
    }
}

(5)中介者模式

概念：

降低多个对象和类之间的通信复杂性，提供了一个中介类处理通信

e.g:MVC中的c层就是m和V之间的中介者

(6)备忘录模式

概念：

保存一个对象的某个状态，以便在适当的时候恢复对象。在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。

应用实例： 1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctrl + z。 4、IE 中的后退。 5、数据库的事务管理。

代码实现：

public class Memento {
    private String state;

    public Memento(String state){
        this.state = state;
    }

    public String getState(){
        return state;
    }
}

/**
 * 生成Memento对象并保存状态
 */
public class Originator {
    private String state;

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

    public String getState() {
        return state;
    }

    public Memento saveStateToMemento(){
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento){
        state=memento.getState();
    }
}

/**8
 * 主要是通过一个Memento列表用于存储之前的Memento
 * 达到存储前一个的状态
 */
public class CareTaker {
    private List<Memento> mementoList=new ArrayList<>();
    public void add(Memento memento){
        mementoList.add(memento);
    }

    public Memento get(int index){
        return mementoList.get(index);
    }
}

public class Client {
    public static void main(String[] args) {
        Originator originator=new Originator();
        CareTaker careTaker=new CareTaker();
        originator.setState("1");
        careTaker.add(originator.saveStateToMemento());
        originator.setState("2");
        careTaker.add(originator.saveStateToMemento());
        originator.setState("3");
        careTaker.add(originator.saveStateToMemento());
        originator.setState("4");
        careTaker.add(originator.saveStateToMemento());
        System.out.println("current:"+originator.getState());
        originator.getStateFromMemento(careTaker.get(0));
        System.out.println("first:"+originator.getState());
        originator.getStateFromMemento(careTaker.get(1));
        System.out.println("second:"+originator.getState());
    }
}